esp32tool 1.4.1 → 1.6.0

package/js/script.js

@@ -1,6 +1,8 @@
 // Import WebUSB serial support for Android compatibility
 import { WebUSBSerial, requestSerialPort } from './webusb-serial.js';
 import { ESP32ToolConsole } from './console.js';
+import { HexEditor } from './hex-editor.js';
+import { NVSEditor } from './nvs-editor.js';
 
 // Make requestSerialPort available globally for esptool.js
 // Use defensive assignment to avoid accidental overwrites
@@ -32,6 +34,8 @@ let currentChipName = null; // Store chip name globally
 let currentMacAddr = null; // Store MAC address globally
 let isConnected = false; // Track connection state
 let consoleInstance = null; // ESP32ToolConsole instance
+let hexEditorInstance = null; // HexEditor instance
+let nvsEditorInstance = null; // NVSEditor instance
 let baudRateBeforeConsole = null; // Store baudrate before opening console
 let espLoaderBeforeConsole = null; // Store original ESPLoader before console
 let chipFamilyBeforeConsole = null; // Store chipFamily before opening console
@@ -88,6 +92,14 @@ function clearAllCachedData() {
   // Show the Read Partition Table button again
   butReadPartitions.classList.remove('hidden');
   
+  // Close NVS editor if open
+  if (nvsEditorInstance) {
+    try { nvsEditorInstance.close(); } catch (_) {}
+    nvsEditorInstance = null;
+  }
+  nvseditorContainer.classList.add('hidden');
+  document.body.classList.remove('nvseditor-active');
+  
   // Hide Detect FS button
   butDetectFS.classList.add('hidden');
   
@@ -228,6 +240,14 @@ const butCloseFileViewer = document.getElementById("butCloseFileViewer");
 const butDownloadFromViewer = document.getElementById("butDownloadFromViewer");
 const tabText = document.getElementById("tabText");
 const tabHex = document.getElementById("tabHex");
+const butHexEditor = document.getElementById("butHexEditor");
+const hexeditorContainer = document.getElementById("hexeditor-container");
+const butNVSEditor = document.getElementById("butNVSEditor");
+const nvseditorContainer = document.getElementById("nvseditor-container");
+
+// NVS and partition table layout constants
+const PARTITION_TABLE_OFFSET = 0x8000;
+const PARTITION_TABLE_SIZE   = 0x1000;
 
 let currentViewedFile = null;
 let currentViewedFileData = null;
@@ -343,6 +363,8 @@ document.addEventListener("DOMContentLoaded", () => {
   butErase.addEventListener("click", clickErase);
   butProgram.addEventListener("click", clickProgram);
   butReadFlash.addEventListener("click", clickReadFlash);
+  butHexEditor.addEventListener("click", clickHexEditor);
+  butNVSEditor.addEventListener("click", clickNVSEditor);
   butReadPartitions.addEventListener("click", clickReadPartitions);
   butDetectFS.addEventListener("click", clickDetectFS);
   butOpenFSManager.addEventListener("click", clickOpenFSManager);
@@ -565,6 +587,36 @@ function enableStyleSheet(node, enabled) {
   node.disabled = !enabled;
 }
 
+/**
+ * Build advanced flash read/write options from the UI controls.
+ * Returns the options object or undefined if advanced mode is off.
+ * @returns {{ chunkSize?: number, blockSize?: number, maxInFlight?: number } | undefined}
+ */
+function buildAdvancedOptions() {
+  if (!advancedMode.checked) return undefined;
+
+  const validate = (name, value) => {
+    if (value === undefined) return undefined;
+    if (!Number.isFinite(value) || value <= 0) {
+      throw new Error(`Invalid ${name}: ${value}`);
+    }
+    return value;
+  };
+
+  const chunkSize = validate("chunkSize", parseInt(chunkSizeSelect.value));
+  const blockSize = validate("blockSize", parseInt(blockSizeSelect.value));
+  const maxInFlight = validate("maxInFlight", parseInt(maxInFlightSelect.value));
+
+  // blockSize and maxInFlight must both be finite or both non-finite
+  const hasBlockSize = Number.isFinite(blockSize);
+  const hasMaxInFlight = Number.isFinite(maxInFlight);
+  if (hasBlockSize !== hasMaxInFlight) {
+    throw new Error("blockSize and maxInFlight must be provided together");
+  }
+
+  return { chunkSize, blockSize, maxInFlight };
+}
+
 /**
  * Parse flash size string (e.g., "256KB", "4MB") to bytes
  * @param {string} sizeStr - Flash size string with unit (KB or MB)
@@ -765,12 +817,14 @@ async function clickConnect() {
   if (isESP8266) {
     // Hide partition table button for ESP8266
     butReadPartitions.classList.add('hidden');
+    butNVSEditor.classList.add('hidden');
     
     // Show ESP8266 filesystem detection button
     butDetectFS.classList.remove('hidden');
   } else {
     // Show partition table button for ESP32
     butReadPartitions.classList.remove('hidden');
+    butNVSEditor.classList.remove('hidden');
     
     // Hide ESP8266 filesystem detection button
     if (butDetectFS) {
@@ -1721,30 +1775,8 @@ async function clickReadFlash() {
     const progressBar = readProgress.querySelector("div");
 
     // Prepare options object if advanced mode is enabled
-    // Option validation helpers
-    const validateOption = (name, value) => {
-      if (value === undefined) return undefined;
-      if (!Number.isFinite(value) || value <= 0) {
-        throw new Error(`Invalid ${name}: ${value}`);
-      }
-      return value;
-    };
-
-    let options = undefined;
-    let chunkSizeOpt, blockSizeOpt, maxInFlightOpt;
-    if (advancedMode.checked) {
-      chunkSizeOpt = validateOption("chunkSize", parseInt(chunkSizeSelect.value));
-      blockSizeOpt = validateOption("blockSize", parseInt(blockSizeSelect.value));
-      maxInFlightOpt = validateOption("maxInFlight", parseInt(maxInFlightSelect.value));
-      if ((blockSizeOpt ?? maxInFlightOpt) &&
-          (blockSizeOpt === undefined || maxInFlightOpt === undefined)) {
-        throw new Error("blockSize and maxInFlight must be provided together");
-      }
-      options = {
-        chunkSize: chunkSizeOpt,
-        blockSize: blockSizeOpt,
-        maxInFlight: maxInFlightOpt
-      };
+    const options = buildAdvancedOptions();
+    if (options) {
       logMsg(`Advanced mode: chunkSize=0x${options.chunkSize?.toString(16)}, blockSize=${options.blockSize}, maxInFlight=${options.maxInFlight}`);
     }
 
@@ -1802,6 +1834,240 @@ async function clickReadFlash() {
   }
 }
 
+/**
+ * @name clickHexEditor
+ * Click handler for the Hex Editor button.
+ * Reads the entire flash into a hex editor window.
+ */
+async function clickHexEditor() {
+  const offset = parseInt(readOffset.value, 16);
+  const size = parseInt(readSize.value, 16);
+
+  if (isNaN(offset) || isNaN(size) || size <= 0) {
+    errorMsg("Invalid offset or size value");
+    return;
+  }
+
+  // Disable button to prevent concurrent reads
+  butHexEditor.disabled = true;
+
+  try {
+    // Create and show hex editor
+    if (!hexEditorInstance) {
+      hexEditorInstance = new HexEditor(hexeditorContainer);
+    }
+
+    // Show the container and progress overlay immediately
+    hexeditorContainer.classList.remove('hidden');
+    document.body.classList.add('hexeditor-active');
+
+    // Build a temporary UI for progress display
+    hexEditorInstance.initProgressUI();
+    hexEditorInstance.showProgress('Reading flash...', 0);
+
+    // Prepare options
+    const options = buildAdvancedOptions();
+
+    const data = await espStub.readFlash(
+      offset,
+      size,
+      (packet, progress, totalSize) => {
+        const pct = Math.floor((progress / totalSize) * 100);
+        hexEditorInstance.showProgress(
+          `Reading flash... ${pct}% (${(progress / 1024).toFixed(0)} / ${(totalSize / 1024).toFixed(0)} KB)`,
+          pct
+        );
+      },
+      options
+    );
+
+    logMsg(`Successfully read ${data.length} bytes from flash for hex editor`);
+
+    // Open hex editor with the data
+    hexEditorInstance.open(data, offset);
+
+    // Set up write handler
+    hexEditorInstance.onWriteFlash = async (editedData, modifiedOffsets) => {
+      // Snapshot the editor instance to avoid null dereference if disconnected mid-write
+      const editor = hexEditorInstance;
+      if (!editor) return;
+
+      // Group modified bytes into contiguous sectors (4KB aligned)
+      const SECTOR_SIZE = 0x1000;
+      const sectors = new Set();
+      for (const off of modifiedOffsets) {
+        sectors.add(Math.floor(off / SECTOR_SIZE) * SECTOR_SIZE);
+      }
+
+      const sortedSectors = [...sectors].sort((a, b) => a - b);
+      let written = 0;
+      const total = sortedSectors.length;
+
+      for (const sectorOff of sortedSectors) {
+        const sectorEnd = Math.min(sectorOff + SECTOR_SIZE, editedData.length);
+        const sectorData = editedData.slice(sectorOff, sectorEnd);
+        const flashAddr = offset + sectorOff;
+
+        editor.showProgress(
+          `Writing sector at 0x${flashAddr.toString(16).toUpperCase()}... (${written + 1}/${total})`,
+          Math.floor((written / total) * 100)
+        );
+
+        await espStub.flashData(
+          sectorData.buffer,
+          (bytesWritten, totalBytes) => {
+            const sectorPct = Math.floor((bytesWritten / totalBytes) * 100);
+            editor.showProgress(
+              `Writing sector at 0x${flashAddr.toString(16).toUpperCase()}... ${sectorPct}% (${written + 1}/${total})`,
+              Math.floor(((written + bytesWritten / totalBytes) / total) * 100)
+            );
+          },
+          flashAddr
+        );
+        written++;
+      }
+
+      editor.showProgress('Write complete!', 100);
+      logMsg(`Successfully wrote ${total} sector(s) to flash`);
+      await sleep(500);
+      editor.hideProgress();
+    };
+
+    // Set up close handler
+    hexEditorInstance.onClose = () => {
+      hexeditorContainer.classList.add('hidden');
+      document.body.classList.remove('hexeditor-active');
+      hexEditorInstance = null;
+    };
+
+  } catch (e) {
+    errorMsg("Failed to read flash for hex editor: " + e);
+    hexeditorContainer.classList.add('hidden');
+    document.body.classList.remove('hexeditor-active');
+    if (hexEditorInstance) {
+     // close() handles ResizeObserver/keydown cleanup; onClose is not yet wired here so null manually
+     try { hexEditorInstance.close(); } catch (_) {}
+     hexEditorInstance = null;
+   }
+  } finally {
+    butHexEditor.disabled = false;
+  }
+}
+
+/**
+ * @name clickNVSEditor
+ * Click handler for the NVS Parser button.
+ * Reads partition table, locates the NVS partition, reads it and opens the NVS editor.
+ */
+async function clickNVSEditor() {
+  butNVSEditor.disabled = true;
+
+  // Guard against losing unsaved changes
+  if (nvsEditorInstance && nvsEditorInstance.modified === true) {
+    if (!confirm('You have unsaved changes in the NVS editor. Discard changes and reload?')) {
+      butNVSEditor.disabled = false;
+      return;
+    }
+    // User confirmed - close existing editor
+    nvseditorContainer.classList.add('hidden');
+    document.body.classList.remove('nvseditor-active');
+    try { nvsEditorInstance.close(); } catch (_) {}
+    nvsEditorInstance = null;
+  }
+
+  try {
+    // Step 1: Read partition table
+    // Create and show NVS editor container with progress
+    if (!nvsEditorInstance) {
+      nvsEditorInstance = new NVSEditor(nvseditorContainer);
+    }
+    nvseditorContainer.classList.remove('hidden');
+    document.body.classList.add('nvseditor-active');
+    nvsEditorInstance.initProgressUI();
+    nvsEditorInstance.showProgress('Reading partition table...', 0);
+
+    const ptData = await espStub.readFlash(PARTITION_TABLE_OFFSET, PARTITION_TABLE_SIZE);
+    const partitions = parsePartitionTable(ptData);
+
+    // Step 2: Find NVS partition (type=0x01 data, subtype=0x02 nvs)
+    const nvsPartition = partitions.find(p => p.type === 0x01 && p.subtype === 0x02);
+    if (!nvsPartition) {
+      throw new Error('No NVS partition found in partition table');
+    }
+
+    logMsg(`Found NVS partition "${nvsPartition.name}" at 0x${nvsPartition.offset.toString(16)}, size ${nvsPartition.size} bytes`);
+
+    // Step 3: Read the NVS partition
+    nvsEditorInstance.showProgress('Reading NVS partition...', 10);
+    const options = buildAdvancedOptions();
+    const nvsData = await espStub.readFlash(
+      nvsPartition.offset,
+      nvsPartition.size,
+      (packet, progress, totalSize) => {
+        const pct = 10 + Math.floor((progress / totalSize) * 85);
+        nvsEditorInstance.showProgress(
+          `Reading NVS... ${Math.floor((progress / totalSize) * 100)}% (${(progress / 1024).toFixed(0)} / ${(totalSize / 1024).toFixed(0)} KB)`,
+          pct
+        );
+      },
+      options
+    );
+
+    logMsg(`Successfully read ${nvsData.length} bytes from NVS partition`);
+
+    // Step 4: Open NVS editor
+    nvsEditorInstance.showProgress('Parsing NVS data...', 95);
+    nvsEditorInstance.open(nvsData, nvsPartition.offset, nvsPartition.name);
+
+    // Step 5: Set up write handler
+    nvsEditorInstance.onWriteFlash = async (editedData) => {
+      const editor = nvsEditorInstance;
+      if (!editor) return;
+
+      editor.showProgress('Writing NVS partition...', 0);
+
+      try {
+        const nvsBuffer = editedData.buffer.slice(
+          editedData.byteOffset,
+          editedData.byteOffset + editedData.byteLength
+      );
+      await espStub.flashData(
+        nvsBuffer,
+        (bytesWritten, totalBytes) => {
+          const pct = Math.floor((bytesWritten / totalBytes) * 100);
+          editor.showProgress(`Writing NVS... ${pct}%`, pct);
+        },
+        nvsPartition.offset
+      );
+
+      editor.showProgress('Write complete!', 100);
+      logMsg('NVS partition written successfully');
+      await sleep(500);
+      } finally {
+        editor.hideProgress();
+      }
+    };
+
+    // Step 6: Set up close handler
+    nvsEditorInstance.onClose = () => {
+      nvseditorContainer.classList.add('hidden');
+      document.body.classList.remove('nvseditor-active');
+      nvsEditorInstance = null;
+    };
+
+  } catch (e) {
+    errorMsg('Failed to open NVS editor: ' + e);
+    nvseditorContainer.classList.add('hidden');
+    document.body.classList.remove('nvseditor-active');
+    if (nvsEditorInstance) {
+      try { nvsEditorInstance.close(); } catch (_) {}
+      nvsEditorInstance = null;
+    }
+  } finally {
+    butNVSEditor.disabled = false;
+  }
+}
+
 /**
  * @name clickOpenFSManager
  * Click handler for the Open FS Manager button (ESP8266)
@@ -1834,8 +2100,6 @@ async function clickOpenFSManager() {
  * Click handler for the read partitions button.
  */
 async function clickReadPartitions() {
-  const PARTITION_TABLE_OFFSET = 0x8000;
-  const PARTITION_TABLE_SIZE = 0x1000; // Read 4KB to get all partitions
 
   butReadPartitions.disabled = true;
   butErase.disabled = true;
@@ -1843,8 +2107,7 @@ async function clickReadPartitions() {
   butReadFlash.disabled = true;
 
   try {
-    logMsg("Reading partition table from 0x8000...");
-    
+    logMsg(`Reading partition table from 0x${PARTITION_TABLE_OFFSET.toString(16)}...`);
     const data = await espStub.readFlash(PARTITION_TABLE_OFFSET, PARTITION_TABLE_SIZE);
     
     const partitions = parsePartitionTable(data);
@@ -2106,6 +2369,8 @@ function toggleUIToolbar(show) {
   }
   butErase.disabled = !show;
   butReadFlash.disabled = !show;
+  butHexEditor.disabled = !show;
+  butNVSEditor.disabled = !show;
   butReadPartitions.disabled = !show;
 }
 
@@ -2136,6 +2401,19 @@ function toggleUIConnected(connected) {
     if (commands) commands.classList.remove("hidden");
     consoleSwitch.checked = false;
     saveSetting("console", false);
+    
+    // Close hex editor if open
+    if (hexEditorInstance) {
+      hexEditorInstance.close();
+      hexEditorInstance = null;
+    }
+    // Close NVS editor if open (disconnect or unexpected port loss)
+    if (nvsEditorInstance) {
+      try { nvsEditorInstance.close(); } catch (_) {}
+      nvsEditorInstance = null;
+    }
+    nvseditorContainer.classList.add('hidden');
+    document.body.classList.remove('nvseditor-active');
   }
   butConnect.textContent = lbl;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "esp32tool",
-  "version": "1.4.1",
+  "version": "1.6.0",
   "type": "module",
   "description": "Flash & Read ESP devices using WebSerial, Electron, and also Android mobile via WebUSB",
   "main": "electron/main.cjs",
@@ -59,7 +59,7 @@
     "@types/serialport": "^10.2.0",
     "@types/w3c-web-serial": "^1.0.7",
     "archiver": "^7.0.1",
-    "electron": "^40.2.1",
+    "electron": "^40.4.1",
     "electron-squirrel-startup": "^1.0.1",
     "eslint": "^9.39.2",
     "eslint-config-prettier": "^10.1.8",
@@ -67,9 +67,9 @@
     "npm-run-all": "^4.1.5",
     "prettier": "^3.8.1",
     "rollup": "^4.57.0",
-    "serve": "^14.2.4",
+    "serve": "^14.2.5",
     "typescript": "^5.7.3",
-    "typescript-eslint": "^8.55.0"
+    "typescript-eslint": "^8.56.0"
   },
   "dependencies": {
     "pako": "^2.1.0",

package/src/cli.ts

@@ -280,7 +280,7 @@ async function connectViaUSB(
     if (webPort) {
       try {
         await webPort.close();
-      } catch (closeErr) {
+      } catch (_closeErr) {
         // Ignore close errors
       }
     }
@@ -582,7 +582,7 @@ async function main() {
     if (esploader) {
       try {
         await esploader.disconnect();
-      } catch (disconnectErr) {
+      } catch (_disconnectErr) {
         // Ignore disconnect errors during error handling
       }
     }

package/src/const.ts

@@ -1,11 +1,9 @@
 import { toByteArray } from "./util";
 
 export interface Logger {
-  /* eslint-disable @typescript-eslint/no-explicit-any */
   log(msg: string, ...args: any[]): void;
   error(msg: string, ...args: any[]): void;
   debug(msg: string, ...args: any[]): void;
-  /* eslint-enable @typescript-eslint/no-explicit-any */
 }
 
 export const baudRates = [

package/src/esp_loader.ts

@@ -1026,14 +1026,18 @@ export class ESPLoader extends EventTarget {
         }
       } else {
         if (step.dtr !== undefined) {
-          webusb
-            ? await this.setDTRWebUSB(step.dtr)
-            : await this.setDTR(step.dtr);
+          if (webusb) {
+            await this.setDTRWebUSB(step.dtr);
+          } else {
+            await this.setDTR(step.dtr);
+          }
         }
         if (step.rts !== undefined) {
-          webusb
-            ? await this.setRTSWebUSB(step.rts)
-            : await this.setRTS(step.rts);
+          if (webusb) {
+            await this.setRTSWebUSB(step.rts);
+          } else {
+            await this.setRTS(step.rts);
+          }
         }
       }
       if (step.delayMs) await sleep(step.delayMs);
@@ -1558,7 +1562,7 @@ export class ESPLoader extends EventTarget {
               `Connected CDC/JTAG successfully with ${strategy.name} reset.`,
             );
             return;
-          } catch (error) {
+          } catch (_error) {
             throw new Error("Sync timeout or abandoned");
           }
         }
@@ -2492,7 +2496,7 @@ export class ESPLoader extends EventTarget {
 
       // Restart Readloop
       this.readLoop();
-    } catch (e) {
+    } catch (_e) {
       //      this.logger.error(`Reconfigure port error: ${e}`);
       //      throw new Error(`Unable to change the baud rate to ${baud}: ${e}`);
     } finally {
@@ -3285,7 +3289,7 @@ export class ESPLoader extends EventTarget {
     // Wait for pending writes to complete
     try {
       await this._writeChain;
-    } catch (err) {
+    } catch (_err) {
       //      this.logger.debug(`Pending write error during disconnect: ${err}`);
     }
 
@@ -3294,7 +3298,7 @@ export class ESPLoader extends EventTarget {
       try {
         await this._writer.close();
         this._writer.releaseLock();
-      } catch (err) {
+      } catch (_err) {
         //        this.logger.debug(`Writer close/release error: ${err}`);
       }
       this._writer = undefined;
@@ -3305,7 +3309,7 @@ export class ESPLoader extends EventTarget {
         const writer = this.port.writable.getWriter();
         await writer.close();
         writer.releaseLock();
-      } catch (err) {
+      } catch (_err) {
         //        this.logger.debug(`Direct writer close error: ${err}`);
       }
     }
@@ -3334,7 +3338,7 @@ export class ESPLoader extends EventTarget {
       // Only cancel if reader is still active
       try {
         this._reader.cancel();
-      } catch (err) {
+      } catch (_err) {
         // Reader already released, resolve immediately
         clearTimeout(timeout);
         resolve(undefined);
@@ -3365,7 +3369,7 @@ export class ESPLoader extends EventTarget {
     // Wait for pending writes to complete
     try {
       await this._writeChain;
-    } catch (err) {
+    } catch (_err) {
       //      this.logger.debug(`Pending write error during release: ${err}`);
     }
 

package/src/node-usb-adapter.ts

@@ -87,7 +87,7 @@ export function createNodeUSBAdapter(
         if (device.configDescriptor?.bConfigurationValue !== 1) {
           device.setConfiguration(1);
         }
-      } catch (err) {
+      } catch (_err) {
         // Already configured
       }
 
@@ -145,7 +145,7 @@ export function createNodeUSBAdapter(
         if (usbInterface.isKernelDriverActive()) {
           usbInterface.detachKernelDriver();
         }
-      } catch (err) {
+      } catch (_err) {
         // Ignore - may not be supported on all platforms
       }
 
@@ -189,7 +189,7 @@ export function createNodeUSBAdapter(
       if (vendorId === 0x10c4) {
         try {
           // Clear halt on endpoints
-          await new Promise<void>((resolve, reject) => {
+          await new Promise<void>((resolve, _reject) => {
             device.controlTransfer(
               0x02, // Clear Feature, Endpoint
               0x01, // ENDPOINT_HALT
@@ -203,7 +203,7 @@ export function createNodeUSBAdapter(
             );
           });
 
-          await new Promise<void>((resolve, reject) => {
+          await new Promise<void>((resolve, _reject) => {
             device.controlTransfer(
               0x02, // Clear Feature, Endpoint
               0x01, // ENDPOINT_HALT
@@ -216,7 +216,7 @@ export function createNodeUSBAdapter(
               },
             );
           });
-        } catch (err) {
+        } catch (_err) {
           // Ignore
         }
       }
@@ -234,7 +234,7 @@ export function createNodeUSBAdapter(
         try {
           endpointIn.stopPoll();
           endpointIn.removeAllListeners();
-        } catch (err) {
+        } catch (_err) {
           // Ignore
         }
       }
@@ -242,7 +242,7 @@ export function createNodeUSBAdapter(
       if (readableStream) {
         try {
           await readableStream.cancel();
-        } catch (err) {
+        } catch (_err) {
           // Ignore
         }
         readableStream = null;
@@ -251,7 +251,7 @@ export function createNodeUSBAdapter(
       if (writableStream) {
         try {
           await writableStream.close();
-        } catch (err) {
+        } catch (_err) {
           // Ignore
         }
         writableStream = null;
@@ -264,14 +264,14 @@ export function createNodeUSBAdapter(
         try {
           const usbInterface = device.interface(interfaceNumber);
           usbInterface.release(true, () => {});
-        } catch (err) {
+        } catch (_err) {
           // Ignore
         }
       }
 
       try {
         device.close();
-      } catch (err) {
+      } catch (_err) {
         // Ignore
       }
     },
@@ -469,7 +469,7 @@ export function createNodeUSBAdapter(
           try {
             logger.error(`USB read error: ${err.message}`);
             // Don't close on error, just log it
-          } catch (e) {
+          } catch (_e) {
             // Ignore errors in error handler
           }
         });
@@ -477,7 +477,7 @@ export function createNodeUSBAdapter(
         endpointIn!.on("end", () => {
           try {
             controller.close();
-          } catch (err) {
+          } catch (_err) {
             // Ignore errors when closing controller
           }
         });
@@ -488,7 +488,7 @@ export function createNodeUSBAdapter(
           try {
             endpointIn.stopPoll();
             endpointIn.removeAllListeners();
-          } catch (err) {
+          } catch (_err) {
             // Ignore
           }
         }