esp32tool 1.6.6 → 1.6.7

package/js/hex-editor.js

@@ -1,6 +1,6 @@
 /**
  * ESP32Tool Flash Hex Editor
- * 
+ *
  * A full-screen hex editor for viewing and editing flash memory content.
  * Features:
  *   - Dual-pane display: HEX (left) + ASCII (right)
@@ -26,10 +26,10 @@ export class HexEditor {
     this.rowHeight = 20;
     this.selectedOffset = -1;
     this.editingPane = null; // 'hex' or 'ascii'
-    this.editBuffer = '';    // partial hex nibble during hex editing
+    this.editBuffer = ""; // partial hex nibble during hex editing
 
     // Search state
-    this.searchMatches = [];   // array of byte offsets
+    this.searchMatches = []; // array of byte offsets
     this.currentMatchIdx = -1;
     this._searchMatchLength = 0;
     this._searchAbort = null; // AbortController for cancelling in-progress search
@@ -82,12 +82,12 @@ export class HexEditor {
     this.currentMatchIdx = -1;
     this.selectedOffset = 0;
     this.editingPane = null;
-    this.editBuffer = '';
+    this.editBuffer = "";
 
     this._buildUI();
-    this.container.classList.remove('hidden');
-    document.body.classList.add('hexeditor-active');
-    document.addEventListener('keydown', this._boundHandleKeyDown);
+    this.container.classList.remove("hidden");
+    document.body.classList.add("hexeditor-active");
+    document.addEventListener("keydown", this._boundHandleKeyDown);
 
     this._calculateLayout();
     this._render();
@@ -104,9 +104,9 @@ export class HexEditor {
 
   /** Close hex editor */
   close() {
-    this.container.classList.add('hidden');
-    document.body.classList.remove('hexeditor-active');
-    document.removeEventListener('keydown', this._boundHandleKeyDown);
+    this.container.classList.add("hidden");
+    document.body.classList.remove("hexeditor-active");
+    document.removeEventListener("keydown", this._boundHandleKeyDown);
     if (this._resizeObserver) {
       this._resizeObserver.disconnect();
       this._resizeObserver = null;
@@ -115,23 +115,23 @@ export class HexEditor {
       this._searchAbort.abort();
       this._searchAbort = null;
     }
-    this.container.innerHTML = '';
+    this.container.innerHTML = "";
     if (this.onClose) this.onClose();
   }
 
   /** Show loading overlay */
   showProgress(text, percent) {
     if (this._progressOverlay) {
-      this._progressOverlay.classList.remove('hidden');
+      this._progressOverlay.classList.remove("hidden");
       this._progressText.textContent = text;
-      this._progressBarInner.style.width = percent + '%';
+      this._progressBarInner.style.width = percent + "%";
     }
   }
 
   /** Hide loading overlay */
   hideProgress() {
     if (this._progressOverlay) {
-      this._progressOverlay.classList.add('hidden');
+      this._progressOverlay.classList.add("hidden");
     }
   }
 
@@ -162,18 +162,19 @@ export class HexEditor {
         </div>
       </div>
     `;
-    this._progressOverlay = this.container.querySelector('#hexedProgress');
-    this._progressText = this.container.querySelector('#hexedProgressText');
-    this._progressBarInner = this.container.querySelector('#hexedProgressBar');
+    this._progressOverlay = this.container.querySelector("#hexedProgress");
+    this._progressText = this.container.querySelector("#hexedProgressText");
+    this._progressBarInner = this.container.querySelector("#hexedProgressBar");
   }
 
   _buildUI() {
     const totalSize = this.data ? this.data.length : 0;
-    const sizeStr = totalSize >= 1024 * 1024
-      ? (totalSize / (1024 * 1024)).toFixed(1) + ' MB'
-      : totalSize >= 1024
-        ? (totalSize / 1024).toFixed(1) + ' KB'
-        : totalSize + ' B';
+    const sizeStr =
+      totalSize >= 1024 * 1024
+        ? (totalSize / (1024 * 1024)).toFixed(1) + " MB"
+        : totalSize >= 1024
+          ? (totalSize / 1024).toFixed(1) + " KB"
+          : totalSize + " B";
 
     this.container.innerHTML = `
       <div class="hexeditor-toolbar">
@@ -222,47 +223,58 @@ export class HexEditor {
     `;
 
     // Cache DOM references
-    this._viewport = this.container.querySelector('#hexedViewport');
-    this._scrollContent = this.container.querySelector('#hexedScrollContent');
-    this._statusOffset = this.container.querySelector('#hexedStatusOffset');
-    this._statusValue = this.container.querySelector('#hexedStatusValue');
-    this._statusModified = this.container.querySelector('#hexedStatusModified');
-    this._searchInput = this.container.querySelector('#hexedSearch');
-    this._searchMode = this.container.querySelector('#hexedSearchMode');
-    this._searchInfo = this.container.querySelector('#hexedSearchInfo');
-    this._gotoInput = this.container.querySelector('#hexedGoto');
-    this._progressOverlay = this.container.querySelector('#hexedProgress');
-    this._progressText = this.container.querySelector('#hexedProgressText');
-    this._progressBarInner = this.container.querySelector('#hexedProgressBar');
-    this._butWrite = this.container.querySelector('#hexedWrite');
+    this._viewport = this.container.querySelector("#hexedViewport");
+    this._scrollContent = this.container.querySelector("#hexedScrollContent");
+    this._statusOffset = this.container.querySelector("#hexedStatusOffset");
+    this._statusValue = this.container.querySelector("#hexedStatusValue");
+    this._statusModified = this.container.querySelector("#hexedStatusModified");
+    this._searchInput = this.container.querySelector("#hexedSearch");
+    this._searchMode = this.container.querySelector("#hexedSearchMode");
+    this._searchInfo = this.container.querySelector("#hexedSearchInfo");
+    this._gotoInput = this.container.querySelector("#hexedGoto");
+    this._progressOverlay = this.container.querySelector("#hexedProgress");
+    this._progressText = this.container.querySelector("#hexedProgressText");
+    this._progressBarInner = this.container.querySelector("#hexedProgressBar");
+    this._butWrite = this.container.querySelector("#hexedWrite");
 
     // Event listeners
-    this.container.querySelector('#hexedClose').addEventListener('click', () => {
-      if (this.hasModifications()) {
-        if (!confirm('You have unsaved modifications. Close anyway?')) return;
-      }
-      this.close();
-    });
-
-    this._butWrite.addEventListener('click', () => this._handleWrite());
-
-    this.container.querySelector('#hexedUndoAll').addEventListener('click', () => {
-      if (this.modifiedOffsets.size === 0) return;
-      if (!confirm(`Undo all ${this.modifiedOffsets.size} modifications?`)) return;
-      for (const offset of this.modifiedOffsets) {
-        this.data[offset] = this.originalData[offset];
-      }
-      this.modifiedOffsets.clear();
-      this._render();
-      this._updateStatus();
-    });
-
-    this.container.querySelector('#hexedSearchBtn').addEventListener('click', () => this._doSearch());
-    this.container.querySelector('#hexedSearchPrev').addEventListener('click', () => this._navigateSearch(-1));
-    this.container.querySelector('#hexedSearchNext').addEventListener('click', () => this._navigateSearch(1));
-
-    this._searchInput.addEventListener('keydown', (e) => {
-      if (e.key === 'Enter') {
+    this.container
+      .querySelector("#hexedClose")
+      .addEventListener("click", () => {
+        if (this.hasModifications()) {
+          if (!confirm("You have unsaved modifications. Close anyway?")) return;
+        }
+        this.close();
+      });
+
+    this._butWrite.addEventListener("click", () => this._handleWrite());
+
+    this.container
+      .querySelector("#hexedUndoAll")
+      .addEventListener("click", () => {
+        if (this.modifiedOffsets.size === 0) return;
+        if (!confirm(`Undo all ${this.modifiedOffsets.size} modifications?`))
+          return;
+        for (const offset of this.modifiedOffsets) {
+          this.data[offset] = this.originalData[offset];
+        }
+        this.modifiedOffsets.clear();
+        this._render();
+        this._updateStatus();
+      });
+
+    this.container
+      .querySelector("#hexedSearchBtn")
+      .addEventListener("click", () => this._doSearch());
+    this.container
+      .querySelector("#hexedSearchPrev")
+      .addEventListener("click", () => this._navigateSearch(-1));
+    this.container
+      .querySelector("#hexedSearchNext")
+      .addEventListener("click", () => this._navigateSearch(1));
+
+    this._searchInput.addEventListener("keydown", (e) => {
+      if (e.key === "Enter") {
         e.preventDefault();
         if (this.searchMatches.length > 0) {
           this._navigateSearch(1);
@@ -273,23 +285,30 @@ export class HexEditor {
     });
 
     // Clear search on input change
-    this._searchInput.addEventListener('input', () => {
+    this._searchInput.addEventListener("input", () => {
       this.searchMatches = [];
       this.currentMatchIdx = -1;
-      this._searchInfo.textContent = '';
+      this._searchInfo.textContent = "";
       this._render();
     });
 
-    this.container.querySelector('#hexedGotoBtn').addEventListener('click', () => this._doGoto());
-    this._gotoInput.addEventListener('keydown', (e) => {
-      if (e.key === 'Enter') { e.preventDefault(); this._doGoto(); }
+    this.container
+      .querySelector("#hexedGotoBtn")
+      .addEventListener("click", () => this._doGoto());
+    this._gotoInput.addEventListener("keydown", (e) => {
+      if (e.key === "Enter") {
+        e.preventDefault();
+        this._doGoto();
+      }
     });
 
     // Virtual scroll
-    this._viewport.addEventListener('scroll', () => this._onScroll());
+    this._viewport.addEventListener("scroll", () => this._onScroll());
 
     // Click handler for cells
-    this._scrollContent.addEventListener('mousedown', (e) => this._handleCellClick(e));
+    this._scrollContent.addEventListener("mousedown", (e) =>
+      this._handleCellClick(e),
+    );
   }
 
   // ──────────────────── Layout & Virtual Scroll ────────────────────
@@ -300,8 +319,8 @@ export class HexEditor {
     const totalHeight = this._totalRows * this.rowHeight;
 
     // Set scroll height
-    this._scrollContent.style.height = totalHeight + 'px';
-    this._scrollContent.style.position = 'relative';
+    this._scrollContent.style.height = totalHeight + "px";
+    this._scrollContent.style.position = "relative";
 
     // Calculate visible rows
     const vpHeight = this._viewport.clientHeight;
@@ -320,7 +339,8 @@ export class HexEditor {
   _scrollToOffset(byteOffset) {
     const row = Math.floor(byteOffset / this.bytesPerRow);
     const vpHeight = this._viewport.clientHeight;
-    const targetScroll = row * this.rowHeight - vpHeight / 2 + this.rowHeight / 2;
+    const targetScroll =
+      row * this.rowHeight - vpHeight / 2 + this.rowHeight / 2;
     this._viewport.scrollTop = Math.max(0, targetScroll);
     this._visibleStart = Math.floor(this._viewport.scrollTop / this.rowHeight);
     this._render();
@@ -338,11 +358,11 @@ export class HexEditor {
     const fragment = document.createDocumentFragment();
 
     // Container for positioned rows
-    const wrapper = document.createElement('div');
-    wrapper.style.position = 'absolute';
-    wrapper.style.top = (start * this.rowHeight) + 'px';
-    wrapper.style.left = '0';
-    wrapper.style.right = '0';
+    const wrapper = document.createElement("div");
+    wrapper.style.position = "absolute";
+    wrapper.style.top = start * this.rowHeight + "px";
+    wrapper.style.left = "0";
+    wrapper.style.right = "0";
 
     for (let row = start; row < end; row++) {
       const rowEl = this._createRow(row);
@@ -351,39 +371,45 @@ export class HexEditor {
 
     // Replace content (keep scroll height div)
     // Remove old rendered wrapper if present
-    const oldWrapper = this._scrollContent.querySelector('.hex-rows-wrapper');
+    const oldWrapper = this._scrollContent.querySelector(".hex-rows-wrapper");
     if (oldWrapper) oldWrapper.remove();
-    wrapper.className = 'hex-rows-wrapper';
+    wrapper.className = "hex-rows-wrapper";
     this._scrollContent.appendChild(wrapper);
   }
 
   _createRow(rowIndex) {
-    const row = document.createElement('div');
-    row.className = 'hexeditor-row';
+    const row = document.createElement("div");
+    row.className = "hexeditor-row";
     const byteStart = rowIndex * this.bytesPerRow;
 
     // Highlight row if selected offset is in this row
-    if (this.selectedOffset >= byteStart && this.selectedOffset < byteStart + this.bytesPerRow) {
-      row.classList.add('highlight-row');
+    if (
+      this.selectedOffset >= byteStart &&
+      this.selectedOffset < byteStart + this.bytesPerRow
+    ) {
+      row.classList.add("highlight-row");
     }
 
     // Address
-    const addr = document.createElement('span');
-    addr.className = 'hexeditor-addr';
-    addr.textContent = (this.baseAddress + byteStart).toString(16).toUpperCase().padStart(8, '0');
+    const addr = document.createElement("span");
+    addr.className = "hexeditor-addr";
+    addr.textContent = (this.baseAddress + byteStart)
+      .toString(16)
+      .toUpperCase()
+      .padStart(8, "0");
     row.appendChild(addr);
 
     // Hex cells
-    const hexDiv = document.createElement('span');
-    hexDiv.className = 'hexeditor-hex';
+    const hexDiv = document.createElement("span");
+    hexDiv.className = "hexeditor-hex";
 
     // Separator
-    const sep = document.createElement('span');
-    sep.className = 'hexeditor-sep';
+    const sep = document.createElement("span");
+    sep.className = "hexeditor-sep";
 
     // ASCII cells
-    const asciiDiv = document.createElement('span');
-    asciiDiv.className = 'hexeditor-ascii';
+    const asciiDiv = document.createElement("span");
+    asciiDiv.className = "hexeditor-ascii";
 
     const bytesInRow = Math.min(this.bytesPerRow, this.data.length - byteStart);
 
@@ -391,58 +417,58 @@ export class HexEditor {
       const offset = byteStart + i;
 
       // Hex cell
-      const hexCell = document.createElement('span');
-      hexCell.className = 'hex-cell';
+      const hexCell = document.createElement("span");
+      hexCell.className = "hex-cell";
       hexCell.dataset.offset = offset;
-      hexCell.dataset.pane = 'hex';
+      hexCell.dataset.pane = "hex";
 
       // ASCII cell
-      const asciiCell = document.createElement('span');
-      asciiCell.className = 'ascii-cell';
+      const asciiCell = document.createElement("span");
+      asciiCell.className = "ascii-cell";
       asciiCell.dataset.offset = offset;
-      asciiCell.dataset.pane = 'ascii';
+      asciiCell.dataset.pane = "ascii";
 
       if (i < bytesInRow) {
         const byte = this.data[offset];
-        const hexStr = byte.toString(16).toUpperCase().padStart(2, '0');
+        const hexStr = byte.toString(16).toUpperCase().padStart(2, "0");
         hexCell.textContent = hexStr;
 
         // Color classes
-        if (byte === 0x00) hexCell.classList.add('zero');
-        else if (byte === 0xFF) hexCell.classList.add('ff');
+        if (byte === 0x00) hexCell.classList.add("zero");
+        else if (byte === 0xff) hexCell.classList.add("ff");
 
         // ASCII char
-        if (byte >= 0x20 && byte <= 0x7E) {
+        if (byte >= 0x20 && byte <= 0x7e) {
           asciiCell.textContent = String.fromCharCode(byte);
         } else {
-          asciiCell.textContent = '·';
-          asciiCell.classList.add('non-printable');
+          asciiCell.textContent = "·";
+          asciiCell.classList.add("non-printable");
         }
 
         // Modified?
         if (this.modifiedOffsets.has(offset)) {
-          hexCell.classList.add('modified');
-          asciiCell.classList.add('modified');
+          hexCell.classList.add("modified");
+          asciiCell.classList.add("modified");
         }
 
         // Selected?
         if (offset === this.selectedOffset) {
-          hexCell.classList.add('selected');
-          asciiCell.classList.add('selected');
+          hexCell.classList.add("selected");
+          asciiCell.classList.add("selected");
         }
 
         // Search match?
         if (this._isSearchMatch(offset)) {
-          hexCell.classList.add('search-match');
-          asciiCell.classList.add('search-match');
+          hexCell.classList.add("search-match");
+          asciiCell.classList.add("search-match");
         }
         if (this._isCurrentSearchMatch(offset)) {
-          hexCell.classList.add('search-current');
-          asciiCell.classList.add('search-current');
+          hexCell.classList.add("search-current");
+          asciiCell.classList.add("search-current");
         }
       } else {
-        hexCell.textContent = '  ';
-        asciiCell.textContent = ' ';
+        hexCell.textContent = "  ";
+        asciiCell.textContent = " ";
       }
 
       hexDiv.appendChild(hexCell);
@@ -458,7 +484,7 @@ export class HexEditor {
   // ──────────────────── Selection & Editing ────────────────────
 
   _handleCellClick(e) {
-    const cell = e.target.closest('[data-offset]');
+    const cell = e.target.closest("[data-offset]");
     if (!cell) return;
 
     const offset = parseInt(cell.dataset.offset);
@@ -466,7 +492,7 @@ export class HexEditor {
 
     this.selectedOffset = offset;
     this.editingPane = cell.dataset.pane;
-    this.editBuffer = '';
+    this.editBuffer = "";
     this._render();
     this._updateStatus();
 
@@ -476,64 +502,68 @@ export class HexEditor {
 
   _handleKeyDown(e) {
     // Only handle when hex editor is visible
-    if (this.container.classList.contains('hidden')) return;
+    if (this.container.classList.contains("hidden")) return;
 
     // Don't intercept when focus is in search/goto inputs
-    if (e.target.tagName === 'INPUT' || e.target.tagName === 'SELECT') return;
+    if (e.target.tagName === "INPUT" || e.target.tagName === "SELECT") return;
 
     const offset = this.selectedOffset;
     if (offset < 0 || !this.data) return;
 
     // Navigation keys
     switch (e.key) {
-      case 'ArrowRight':
+      case "ArrowRight":
         e.preventDefault();
         this._selectOffset(Math.min(offset + 1, this.data.length - 1));
         return;
-      case 'ArrowLeft':
+      case "ArrowLeft":
         e.preventDefault();
         this._selectOffset(Math.max(offset - 1, 0));
         return;
-      case 'ArrowDown':
+      case "ArrowDown":
         e.preventDefault();
-        this._selectOffset(Math.min(offset + this.bytesPerRow, this.data.length - 1));
+        this._selectOffset(
+          Math.min(offset + this.bytesPerRow, this.data.length - 1),
+        );
         return;
-      case 'ArrowUp':
+      case "ArrowUp":
         e.preventDefault();
         this._selectOffset(Math.max(offset - this.bytesPerRow, 0));
         return;
-      case 'PageDown':
+      case "PageDown":
         e.preventDefault();
-        this._selectOffset(Math.min(offset + this.bytesPerRow * 16, this.data.length - 1));
+        this._selectOffset(
+          Math.min(offset + this.bytesPerRow * 16, this.data.length - 1),
+        );
         return;
-      case 'PageUp':
+      case "PageUp":
         e.preventDefault();
         this._selectOffset(Math.max(offset - this.bytesPerRow * 16, 0));
         return;
-      case 'Home':
+      case "Home":
         if (e.ctrlKey || e.metaKey) {
           e.preventDefault();
           this._selectOffset(0);
         }
         return;
-      case 'End':
+      case "End":
         if (e.ctrlKey || e.metaKey) {
           e.preventDefault();
           this._selectOffset(this.data.length - 1);
         }
         return;
-      case 'Tab':
+      case "Tab":
         e.preventDefault();
-        this.editingPane = this.editingPane === 'hex' ? 'ascii' : 'hex';
-        this.editBuffer = '';
+        this.editingPane = this.editingPane === "hex" ? "ascii" : "hex";
+        this.editBuffer = "";
         this._render();
         return;
     }
 
     // Editing
-    if (this.editingPane === 'hex') {
+    if (this.editingPane === "hex") {
       this._handleHexEdit(e);
-    } else if (this.editingPane === 'ascii') {
+    } else if (this.editingPane === "ascii") {
       this._handleAsciiEdit(e);
     }
   }
@@ -547,9 +577,11 @@ export class HexEditor {
     if (this.editBuffer.length === 2) {
       const newByte = parseInt(this.editBuffer, 16);
       this._setByte(this.selectedOffset, newByte);
-      this.editBuffer = '';
+      this.editBuffer = "";
       // Move to next byte
-      this._selectOffset(Math.min(this.selectedOffset + 1, this.data.length - 1));
+      this._selectOffset(
+        Math.min(this.selectedOffset + 1, this.data.length - 1),
+      );
     } else {
       // Show partial edit feedback – re-render to update status
       this._updateStatus();
@@ -561,7 +593,7 @@ export class HexEditor {
     e.preventDefault();
 
     const newByte = e.key.charCodeAt(0);
-    if (newByte < 0x20 || newByte > 0x7E) return; // only printable ASCII
+    if (newByte < 0x20 || newByte > 0x7e) return; // only printable ASCII
 
     this._setByte(this.selectedOffset, newByte);
     this._selectOffset(Math.min(this.selectedOffset + 1, this.data.length - 1));
@@ -569,7 +601,8 @@ export class HexEditor {
 
   _setByte(offset, value) {
     if (offset < 0 || offset >= this.data.length) return;
-    if (this.data[offset] === value && !this.modifiedOffsets.has(offset)) return;
+    if (this.data[offset] === value && !this.modifiedOffsets.has(offset))
+      return;
 
     this.data[offset] = value;
 
@@ -586,7 +619,7 @@ export class HexEditor {
 
   _selectOffset(offset) {
     this.selectedOffset = offset;
-    this.editBuffer = '';
+    this.editBuffer = "";
 
     // Ensure visible
     const row = Math.floor(offset / this.bytesPerRow);
@@ -613,10 +646,14 @@ export class HexEditor {
     const mode = this._searchMode.value;
     let searchBytes;
 
-    if (mode === 'hex') {
+    if (mode === "hex") {
       // Parse hex string: allow spaces, commas
-      const cleaned = query.replace(/[,\s]/g, '');
-      if (!/^[0-9a-fA-F]*$/.test(cleaned) || cleaned.length === 0 || cleaned.length % 2 !== 0) {
+      const cleaned = query.replace(/[,\s]/g, "");
+      if (
+        !/^[0-9a-fA-F]*$/.test(cleaned) ||
+        cleaned.length === 0 ||
+        cleaned.length % 2 !== 0
+      ) {
         this._searchInfo.textContent = 'Invalid hex (e.g. "48 65 6C 6C 6F")';
         return;
       }
@@ -643,7 +680,7 @@ export class HexEditor {
 
     this.searchMatches = [];
     this.currentMatchIdx = -1;
-    this._searchInfo.textContent = 'Searching...';
+    this._searchInfo.textContent = "Searching...";
     this._render();
 
     // Non-blocking chunked search to keep UI responsive
@@ -655,7 +692,7 @@ export class HexEditor {
 
     if (this.searchMatches.length > 0) {
       // Jump to first match at or after current selection
-      let idx = this.searchMatches.findIndex(m => m >= this.selectedOffset);
+      let idx = this.searchMatches.findIndex((m) => m >= this.selectedOffset);
       if (idx === -1) idx = 0;
       this.currentMatchIdx = idx;
       this._searchInfo.textContent = `${idx + 1} / ${this.searchMatches.length} matches`;
@@ -663,7 +700,7 @@ export class HexEditor {
       this._scrollToOffset(this.selectedOffset);
     } else {
       this.currentMatchIdx = -1;
-      this._searchInfo.textContent = 'No matches found';
+      this._searchInfo.textContent = "No matches found";
     }
 
     this._render();
@@ -692,7 +729,10 @@ export class HexEditor {
       }
 
       const processChunk = () => {
-        if (signal.aborted) { resolve([]); return; }
+        if (signal.aborted) {
+          resolve([]);
+          return;
+        }
 
         const end = Math.min(pos + CHUNK, len);
         while (pos <= end) {
@@ -724,8 +764,10 @@ export class HexEditor {
     if (this.searchMatches.length === 0) return;
 
     this.currentMatchIdx += direction;
-    if (this.currentMatchIdx >= this.searchMatches.length) this.currentMatchIdx = 0;
-    if (this.currentMatchIdx < 0) this.currentMatchIdx = this.searchMatches.length - 1;
+    if (this.currentMatchIdx >= this.searchMatches.length)
+      this.currentMatchIdx = 0;
+    if (this.currentMatchIdx < 0)
+      this.currentMatchIdx = this.searchMatches.length - 1;
 
     this.selectedOffset = this.searchMatches[this.currentMatchIdx];
     this._searchInfo.textContent = `${this.currentMatchIdx + 1} / ${this.searchMatches.length} matches`;
@@ -737,11 +779,15 @@ export class HexEditor {
   _isSearchMatch(offset) {
     if (this.searchMatches.length === 0) return false;
     const len = this._searchMatchLength || 1;
-    return this.searchMatches.some(m => offset >= m && offset < m + len);
+    return this.searchMatches.some((m) => offset >= m && offset < m + len);
   }
 
   _isCurrentSearchMatch(offset) {
-    if (this.currentMatchIdx < 0 || this.currentMatchIdx >= this.searchMatches.length) return false;
+    if (
+      this.currentMatchIdx < 0 ||
+      this.currentMatchIdx >= this.searchMatches.length
+    )
+      return false;
     const m = this.searchMatches[this.currentMatchIdx];
     const len = this._searchMatchLength || 1;
     return offset >= m && offset < m + len;
@@ -750,15 +796,17 @@ export class HexEditor {
   // ──────────────────── Go To Address ────────────────────
 
   _doGoto() {
-    const val = this._gotoInput.value.trim().replace(/^0x/i, '');
+    const val = this._gotoInput.value.trim().replace(/^0x/i, "");
     const addr = parseInt(val, 16);
     if (isNaN(addr)) return;
 
     // Convert absolute address to offset
     const offset = addr >= this.baseAddress ? addr - this.baseAddress : addr;
     if (offset < 0 || offset >= this.data.length) {
-      this._gotoInput.style.borderColor = '#c62828';
-      setTimeout(() => { this._gotoInput.style.borderColor = ''; }, 1000);
+      this._gotoInput.style.borderColor = "#c62828";
+      setTimeout(() => {
+        this._gotoInput.style.borderColor = "";
+      }, 1000);
       return;
     }
 
@@ -773,28 +821,29 @@ export class HexEditor {
       const off = this.selectedOffset;
       const absAddr = this.baseAddress + off;
       const byte = this.data[off];
-      const hexStr = byte.toString(16).toUpperCase().padStart(2, '0');
+      const hexStr = byte.toString(16).toUpperCase().padStart(2, "0");
       const dec = byte;
-      const bin = byte.toString(2).padStart(8, '0');
-      const chr = (byte >= 0x20 && byte <= 0x7E) ? `'${String.fromCharCode(byte)}'` : '-';
+      const bin = byte.toString(2).padStart(8, "0");
+      const chr =
+        byte >= 0x20 && byte <= 0x7e ? `'${String.fromCharCode(byte)}'` : "-";
+
+      this._statusOffset.textContent = `Offset: 0x${absAddr.toString(16).toUpperCase().padStart(8, "0")} (${off})`;
 
-      this._statusOffset.textContent = `Offset: 0x${absAddr.toString(16).toUpperCase().padStart(8, '0')} (${off})`;
-      
       let valueStr = `Hex: 0x${hexStr} | Dec: ${dec} | Bin: ${bin} | Char: ${chr}`;
       if (this.editBuffer.length > 0) {
         valueStr += ` [typing: ${this.editBuffer}_]`;
       }
       this._statusValue.textContent = valueStr;
     } else {
-      this._statusOffset.textContent = 'Offset: -';
-      this._statusValue.textContent = 'Value: -';
+      this._statusOffset.textContent = "Offset: -";
+      this._statusValue.textContent = "Value: -";
     }
 
     if (this.modifiedOffsets.size > 0) {
       this._statusModified.textContent = `● ${this.modifiedOffsets.size} byte(s) modified`;
       this._butWrite.disabled = false;
     } else {
-      this._statusModified.textContent = '';
+      this._statusModified.textContent = "";
       this._butWrite.disabled = true;
     }
   }
@@ -804,18 +853,22 @@ export class HexEditor {
   async _handleWrite() {
     if (this.modifiedOffsets.size === 0) return;
     if (!this.onWriteFlash) {
-      alert('Write handler not configured');
+      alert("Write handler not configured");
       return;
     }
 
     const count = this.modifiedOffsets.size;
-    if (!confirm(`Write ${count} modified byte(s) to flash?\n\nThis will erase and reprogram affected sectors.`)) {
+    if (
+      !confirm(
+        `Write ${count} modified byte(s) to flash?\n\nThis will erase and reprogram affected sectors.`,
+      )
+    ) {
       return;
     }
 
     try {
       this._butWrite.disabled = true;
-      this.showProgress('Writing changes to flash...', 0);
+      this.showProgress("Writing changes to flash...", 0);
       await this.onWriteFlash(this.data, this.modifiedOffsets);
 
       // Update original snapshot after successful write
@@ -827,7 +880,7 @@ export class HexEditor {
     } catch (err) {
       this.hideProgress();
       this._butWrite.disabled = false;
-      alert('Write failed: ' + (err.message || err));
+      alert("Write failed: " + (err.message || err));
     }
   }
 }