tasmota-webserial-esptool 7.0.0 → 7.1.0

package/dist/const.js

@@ -307,7 +307,7 @@ export const FLASH_READ_TIMEOUT = 100; // timeout for reading flash in ms
  * Scales timeouts which are size-specific
  */
 export const timeoutPerMb = (secondsPerMb, sizeBytes) => {
-    let result = Math.floor(secondsPerMb * (sizeBytes / 0x1e6));
+    const result = Math.floor(secondsPerMb * (sizeBytes / 0x1e6));
     if (result < DEFAULT_TIMEOUT) {
         return DEFAULT_TIMEOUT;
     }

package/dist/esp_loader.d.ts

@@ -132,7 +132,7 @@ export declare class ESPLoader extends EventTarget {
      * @name flashDeflBegin
      *
      */
-    flashDeflBegin(size?: number, compressedSize?: number, offset?: number, encrypted?: boolean): Promise<number>;
+    flashDeflBegin(size?: number, compressedSize?: number, offset?: number): Promise<number>;
     flashFinish(): Promise<void>;
     flashDeflFinish(): Promise<void>;
     getBootloaderOffset(): number;
@@ -199,7 +199,7 @@ declare class EspStubLoader extends ESPLoader {
      * @name memBegin (592)
      * Start downloading an application image to RAM
      */
-    memBegin(size: number, blocks: number, blocksize: number, offset: number): Promise<any>;
+    memBegin(size: number, _blocks: number, _blocksize: number, offset: number): Promise<[number, number[]]>;
     /**
      * @name getEraseSize
      * depending on flash chip model the erase may take this long (maybe longer!)

package/dist/esp_loader.js

@@ -2,7 +2,7 @@
 import { CHIP_FAMILY_ESP32, CHIP_FAMILY_ESP32S2, CHIP_FAMILY_ESP32S3, CHIP_FAMILY_ESP32C2, CHIP_FAMILY_ESP32C3, CHIP_FAMILY_ESP32C5, CHIP_FAMILY_ESP32C6, CHIP_FAMILY_ESP32C61, CHIP_FAMILY_ESP32H2, CHIP_FAMILY_ESP32H4, CHIP_FAMILY_ESP32H21, CHIP_FAMILY_ESP32P4, CHIP_FAMILY_ESP32S31, CHIP_FAMILY_ESP8266, MAX_TIMEOUT, DEFAULT_TIMEOUT, ERASE_REGION_TIMEOUT_PER_MB, ESP_CHANGE_BAUDRATE, ESP_CHECKSUM_MAGIC, ESP_FLASH_BEGIN, ESP_FLASH_DATA, ESP_FLASH_END, ESP_MEM_BEGIN, ESP_MEM_DATA, ESP_MEM_END, ESP_READ_REG, ESP_WRITE_REG, ESP_SPI_ATTACH, ESP_SYNC, ESP_GET_SECURITY_INFO, FLASH_SECTOR_SIZE, FLASH_WRITE_SIZE, STUB_FLASH_WRITE_SIZE, MEM_END_ROM_TIMEOUT, ROM_INVALID_RECV_MSG, SYNC_PACKET, SYNC_TIMEOUT, USB_RAM_BLOCK, ESP_ERASE_FLASH, ESP_READ_FLASH, CHIP_ERASE_TIMEOUT, FLASH_READ_TIMEOUT, timeoutPerMb, ESP_ROM_BAUD, USB_JTAG_SERIAL_PID, ESP_FLASH_DEFL_BEGIN, ESP_FLASH_DEFL_DATA, ESP_FLASH_DEFL_END, getSpiFlashAddresses, DETECTED_FLASH_SIZES, CHIP_DETECT_MAGIC_REG_ADDR, CHIP_DETECT_MAGIC_VALUES, CHIP_ID_TO_INFO, ESP32P4_EFUSE_BLOCK1_ADDR, SlipReadError, } from "./const";
 import { getStubCode } from "./stubs";
 import { hexFormatter, sleep, slipEncode, toHex } from "./util";
-// @ts-ignore
+// @ts-expect-error pako ESM module doesn't have proper type definitions
 import { deflate } from "pako/dist/pako.esm.mjs";
 import { pack, unpack } from "./struct";
 export class ESPLoader extends EventTarget {
@@ -63,6 +63,7 @@ export class ESPLoader extends EventTarget {
             },
             0x303a: {
                 // Espressif (native USB)
+                0x2: { name: "ESP32-S2 Native USB", maxBaudrate: 2000000 },
                 0x1001: { name: "ESP32 Native USB", maxBaudrate: 2000000 },
                 0x1002: { name: "ESP32 Native USB", maxBaudrate: 2000000 },
                 0x4002: { name: "ESP32 Native USB", maxBaudrate: 2000000 },
@@ -101,8 +102,8 @@ export class ESPLoader extends EventTarget {
         // Detect chip type
         await this.detectChip();
         // Read the OTP data for this chip and store into this.efuses array
-        let FlAddr = getSpiFlashAddresses(this.getChipFamily());
-        let AddrMAC = FlAddr.macFuse;
+        const FlAddr = getSpiFlashAddresses(this.getChipFamily());
+        const AddrMAC = FlAddr.macFuse;
         for (let i = 0; i < 4; i++) {
             this._efuses[i] = await this.readRegister(AddrMAC + 4 * i);
         }
@@ -139,9 +140,9 @@ export class ESPLoader extends EventTarget {
             }
             this.logger.debug(`Unknown IMAGE_CHIP_ID: ${chipId}, falling back to magic value detection`);
         }
-        catch (err) {
+        catch (error) {
             // GET_SECURITY_INFO not supported, fall back to magic value detection
-            this.logger.debug(`GET_SECURITY_INFO failed, using magic value detection: ${err}`);
+            this.logger.debug(`GET_SECURITY_INFO failed, using magic value detection: ${error}`);
             // Clear input buffer and re-sync to recover from failed command
             this._inputBuffer.length = 0;
             await sleep(SYNC_TIMEOUT);
@@ -154,8 +155,8 @@ export class ESPLoader extends EventTarget {
             }
         }
         // Fallback: Use magic value detection for ESP8266, ESP32, ESP32-S2, and ESP32-P4 RC versions
-        let chipMagicValue = await this.readRegister(CHIP_DETECT_MAGIC_REG_ADDR);
-        let chip = CHIP_DETECT_MAGIC_VALUES[chipMagicValue >>> 0];
+        const chipMagicValue = await this.readRegister(CHIP_DETECT_MAGIC_REG_ADDR);
+        const chip = CHIP_DETECT_MAGIC_VALUES[chipMagicValue >>> 0];
         if (chip === undefined) {
             throw new Error(`Unknown Chip: Hex: ${toHex(chipMagicValue >>> 0, 8).toLowerCase()} Number: ${chipMagicValue}`);
         }
@@ -196,7 +197,7 @@ export class ESPLoader extends EventTarget {
      * Get security info including chip ID (ESP32-C3 and later)
      */
     async getSecurityInfo() {
-        const [_, responseData] = await this.checkCommand(ESP_GET_SECURITY_INFO, [], 0);
+        const [, responseData] = await this.checkCommand(ESP_GET_SECURITY_INFO, [], 0);
         // Some chips/ROM versions return empty response or don't support this command
         if (responseData.length === 0) {
             throw new Error(`GET_SECURITY_INFO not supported or returned empty response`);
@@ -231,10 +232,12 @@ export class ESPLoader extends EventTarget {
         }
         this._reader = this.port.readable.getReader();
         try {
-            while (true) {
+            let keepReading = true;
+            while (keepReading) {
                 const { value, done } = await this._reader.read();
                 if (done) {
                     this._reader.releaseLock();
+                    keepReading = false;
                     break;
                 }
                 if (!value || value.length === 0) {
@@ -248,8 +251,8 @@ export class ESPLoader extends EventTarget {
                 this._totalBytesRead += value.length;
             }
         }
-        catch (err) {
-            console.error("Read loop got disconnected");
+        catch {
+            this.logger.error("Read loop got disconnected");
         }
         // Disconnected!
         this.connected = false;
@@ -320,11 +323,11 @@ export class ESPLoader extends EventTarget {
      * The MAC address burned into the OTP memory of the ESP chip
      */
     macAddr() {
-        let macAddr = new Array(6).fill(0);
-        let mac0 = this._efuses[0];
-        let mac1 = this._efuses[1];
-        let mac2 = this._efuses[2];
-        let mac3 = this._efuses[3];
+        const macAddr = new Array(6).fill(0);
+        const mac0 = this._efuses[0];
+        const mac1 = this._efuses[1];
+        const mac2 = this._efuses[2];
+        const mac3 = this._efuses[3];
         let oui;
         if (this.chipFamily == CHIP_FAMILY_ESP8266) {
             if (mac3 != 0) {
@@ -382,9 +385,9 @@ export class ESPLoader extends EventTarget {
         if (this.debug) {
             this.logger.debug("Reading from Register " + toHex(reg, 8));
         }
-        let packet = pack("<I", reg);
+        const packet = pack("<I", reg);
         await this.sendCommand(ESP_READ_REG, packet);
-        let [val, _data] = await this.getResponse(ESP_READ_REG);
+        const [val] = await this.getResponse(ESP_READ_REG);
         return val;
     }
     /**
@@ -396,10 +399,11 @@ export class ESPLoader extends EventTarget {
     async checkCommand(opcode, buffer, checksum = 0, timeout = DEFAULT_TIMEOUT) {
         timeout = Math.min(timeout, MAX_TIMEOUT);
         await this.sendCommand(opcode, buffer, checksum);
-        let [value, data] = await this.getResponse(opcode, timeout);
-        if (data === null) {
+        const [value, responseData] = await this.getResponse(opcode, timeout);
+        if (responseData === null) {
             throw new Error("Didn't get enough status bytes");
         }
+        let data = responseData;
         let statusLen = 0;
         if (this.IS_STUB || this.chipFamily == CHIP_FAMILY_ESP8266) {
             statusLen = 2;
@@ -434,7 +438,7 @@ export class ESPLoader extends EventTarget {
         if (data.length < statusLen) {
             throw new Error("Didn't get enough status bytes");
         }
-        let status = data.slice(-statusLen, data.length);
+        const status = data.slice(-statusLen, data.length);
         data = data.slice(0, -statusLen);
         if (this.debug) {
             this.logger.debug("status", status);
@@ -457,7 +461,7 @@ export class ESPLoader extends EventTarget {
      * does not check response
      */
     async sendCommand(opcode, buffer, checksum = 0) {
-        let packet = slipEncode([
+        const packet = slipEncode([
             ...pack("<BBHI", 0x00, opcode, buffer.length, checksum),
             ...buffer,
         ]);
@@ -476,7 +480,7 @@ export class ESPLoader extends EventTarget {
         let inEscape = false;
         let readBytes = [];
         while (true) {
-            let stamp = Date.now();
+            const stamp = Date.now();
             readBytes = [];
             while (Date.now() - stamp < timeout) {
                 if (this._inputBuffer.length > 0) {
@@ -489,12 +493,12 @@ export class ESPLoader extends EventTarget {
                 }
             }
             if (readBytes.length == 0) {
-                let waitingFor = partialPacket === null ? "header" : "content";
+                const waitingFor = partialPacket === null ? "header" : "content";
                 throw new SlipReadError("Timed out waiting for packet " + waitingFor);
             }
             if (this.debug)
                 this.logger.debug("Read " + readBytes.length + " bytes: " + hexFormatter(readBytes));
-            for (let b of readBytes) {
+            for (const b of readBytes) {
                 if (partialPacket === null) {
                     // waiting for packet header
                     if (b == 0xc0) {
@@ -557,7 +561,7 @@ export class ESPLoader extends EventTarget {
             if (packet.length < 8) {
                 continue;
             }
-            const [resp, opRet, _lenRet, val] = unpack("<BBHI", packet.slice(0, 8));
+            const [resp, opRet, , val] = unpack("<BBHI", packet.slice(0, 8));
             if (resp != 1) {
                 continue;
             }
@@ -577,7 +581,7 @@ export class ESPLoader extends EventTarget {
      * Calculate checksum of a blob, as it is defined by the ROM
      */
     checksum(data, state = ESP_CHECKSUM_MAGIC) {
-        for (let b of data) {
+        for (const b of data) {
             state ^= b;
         }
         return state;
@@ -588,11 +592,11 @@ export class ESPLoader extends EventTarget {
         }
         try {
             // Send ESP_ROM_BAUD(115200) as the old one if running STUB otherwise 0
-            let buffer = pack("<II", baud, this.IS_STUB ? ESP_ROM_BAUD : 0);
+            const buffer = pack("<II", baud, this.IS_STUB ? ESP_ROM_BAUD : 0);
             await this.checkCommand(ESP_CHANGE_BAUDRATE, buffer);
         }
         catch (e) {
-            console.error(e);
+            this.logger.error(`Baudrate change error: ${e}`);
             throw new Error(`Unable to change the baud rate to ${baud}: No response from set baud rate command.`);
         }
         if (this._parent) {
@@ -635,7 +639,7 @@ export class ESPLoader extends EventTarget {
             this.readLoop();
         }
         catch (e) {
-            console.error(e);
+            this.logger.error(`Reconfigure port error: ${e}`);
             throw new Error(`Unable to change the baud rate to ${baud}: ${e}`);
         }
     }
@@ -647,7 +651,7 @@ export class ESPLoader extends EventTarget {
     async sync() {
         for (let i = 0; i < 5; i++) {
             this._inputBuffer.length = 0;
-            let response = await this._sync();
+            const response = await this._sync();
             if (response) {
                 await sleep(SYNC_TIMEOUT);
                 return true;
@@ -665,12 +669,12 @@ export class ESPLoader extends EventTarget {
         await this.sendCommand(ESP_SYNC, SYNC_PACKET);
         for (let i = 0; i < 8; i++) {
             try {
-                let [_reply, data] = await this.getResponse(ESP_SYNC, SYNC_TIMEOUT);
+                const [, data] = await this.getResponse(ESP_SYNC, SYNC_TIMEOUT);
                 if (data.length > 1 && data[0] == 0 && data[1] == 0) {
                     return true;
                 }
             }
-            catch (err) {
+            catch {
                 // If read packet fails.
             }
         }
@@ -696,13 +700,13 @@ export class ESPLoader extends EventTarget {
     async flashData(binaryData, updateProgress, offset = 0, compress = false) {
         if (binaryData.byteLength >= 8) {
             // unpack the (potential) image header
-            var header = Array.from(new Uint8Array(binaryData, 0, 4));
-            let headerMagic = header[0];
-            let headerFlashMode = header[2];
-            let headerFlashSizeFreq = header[3];
+            const header = Array.from(new Uint8Array(binaryData, 0, 4));
+            const headerMagic = header[0];
+            const headerFlashMode = header[2];
+            const headerFlashSizeFreq = header[3];
             this.logger.log(`Image header, Magic=${toHex(headerMagic)}, FlashMode=${toHex(headerFlashMode)}, FlashSizeFreq=${toHex(headerFlashSizeFreq)}`);
         }
-        let uncompressedFilesize = binaryData.byteLength;
+        const uncompressedFilesize = binaryData.byteLength;
         let compressedFilesize = 0;
         let dataToFlash;
         let timeout = DEFAULT_TIMEOUT;
@@ -723,9 +727,9 @@ export class ESPLoader extends EventTarget {
         let seq = 0;
         let written = 0;
         let position = 0;
-        let stamp = Date.now();
-        let flashWriteSize = this.getFlashWriteSize();
-        let filesize = compress ? compressedFilesize : uncompressedFilesize;
+        const stamp = Date.now();
+        const flashWriteSize = this.getFlashWriteSize();
+        const filesize = compress ? compressedFilesize : uncompressedFilesize;
         while (filesize - position > 0) {
             if (this.debug) {
                 this.logger.log(`Writing at ${toHex(offset + seq * flashWriteSize, 8)} `);
@@ -786,8 +790,7 @@ export class ESPLoader extends EventTarget {
         // Flush serial buffers before flash write operation
         await this.flushSerialBuffers();
         let eraseSize;
-        let buffer;
-        let flashWriteSize = this.getFlashWriteSize();
+        const flashWriteSize = this.getFlashWriteSize();
         if (!this.IS_STUB &&
             [
                 CHIP_FAMILY_ESP32,
@@ -806,22 +809,18 @@ export class ESPLoader extends EventTarget {
             ].includes(this.chipFamily)) {
             await this.checkCommand(ESP_SPI_ATTACH, new Array(8).fill(0));
         }
-        let numBlocks = Math.floor((size + flashWriteSize - 1) / flashWriteSize);
+        const numBlocks = Math.floor((size + flashWriteSize - 1) / flashWriteSize);
         if (this.chipFamily == CHIP_FAMILY_ESP8266) {
             eraseSize = this.getEraseSize(offset, size);
         }
         else {
             eraseSize = size;
         }
-        let timeout;
-        if (this.IS_STUB) {
-            timeout = DEFAULT_TIMEOUT;
-        }
-        else {
-            timeout = timeoutPerMb(ERASE_REGION_TIMEOUT_PER_MB, size);
-        }
-        let stamp = Date.now();
-        buffer = pack("<IIII", eraseSize, numBlocks, flashWriteSize, offset);
+        const timeout = this.IS_STUB
+            ? DEFAULT_TIMEOUT
+            : timeoutPerMb(ERASE_REGION_TIMEOUT_PER_MB, size);
+        const stamp = Date.now();
+        let buffer = pack("<IIII", eraseSize, numBlocks, flashWriteSize, offset);
         if (this.chipFamily == CHIP_FAMILY_ESP32 ||
             this.chipFamily == CHIP_FAMILY_ESP32S2 ||
             this.chipFamily == CHIP_FAMILY_ESP32S3 ||
@@ -857,15 +856,14 @@ export class ESPLoader extends EventTarget {
      * @name flashDeflBegin
      *
      */
-    async flashDeflBegin(size = 0, compressedSize = 0, offset = 0, encrypted = false) {
+    async flashDeflBegin(size = 0, compressedSize = 0, offset = 0) {
         // Start downloading compressed data to Flash (performs an erase)
         // Returns number of blocks to write.
-        let flashWriteSize = this.getFlashWriteSize();
-        let numBlocks = Math.floor((compressedSize + flashWriteSize - 1) / flashWriteSize);
-        let eraseBlocks = Math.floor((size + flashWriteSize - 1) / flashWriteSize);
+        const flashWriteSize = this.getFlashWriteSize();
+        const numBlocks = Math.floor((compressedSize + flashWriteSize - 1) / flashWriteSize);
+        const eraseBlocks = Math.floor((size + flashWriteSize - 1) / flashWriteSize);
         let writeSize = 0;
         let timeout = 0;
-        let buffer;
         if (this.IS_STUB) {
             writeSize = size; // stub expects number of bytes here, manages erasing internally
             timeout = timeoutPerMb(ERASE_REGION_TIMEOUT_PER_MB, writeSize); // ROM performs the erase up front
@@ -874,26 +872,26 @@ export class ESPLoader extends EventTarget {
             writeSize = eraseBlocks * flashWriteSize; // ROM expects rounded up to erase block size
             timeout = DEFAULT_TIMEOUT;
         }
-        buffer = pack("<IIII", writeSize, numBlocks, flashWriteSize, offset);
+        const buffer = pack("<IIII", writeSize, numBlocks, flashWriteSize, offset);
         await this.checkCommand(ESP_FLASH_DEFL_BEGIN, buffer, 0, timeout);
         return timeout;
     }
     async flashFinish() {
-        let buffer = pack("<I", 1);
+        const buffer = pack("<I", 1);
         await this.checkCommand(ESP_FLASH_END, buffer);
     }
     async flashDeflFinish() {
-        let buffer = pack("<I", 1);
+        const buffer = pack("<I", 1);
         await this.checkCommand(ESP_FLASH_DEFL_END, buffer);
     }
     getBootloaderOffset() {
-        let bootFlashOffs = getSpiFlashAddresses(this.getChipFamily());
-        let BootldrFlashOffs = bootFlashOffs.flashOffs;
+        const bootFlashOffs = getSpiFlashAddresses(this.getChipFamily());
+        const BootldrFlashOffs = bootFlashOffs.flashOffs;
         return BootldrFlashOffs;
     }
     async flashId() {
-        let SPIFLASH_RDID = 0x9f;
-        let result = await this.runSpiFlashCommand(SPIFLASH_RDID, [], 24);
+        const SPIFLASH_RDID = 0x9f;
+        const result = await this.runSpiFlashCommand(SPIFLASH_RDID, [], 24);
         return result;
     }
     getChipFamily() {
@@ -903,15 +901,15 @@ export class ESPLoader extends EventTarget {
         let buffer = pack("<IIII", address, value, mask, delayUs);
         if (delayAfterUs > 0) {
             // add a dummy write to a date register as an excuse to have a delay
-            buffer.concat(pack("<IIII", getSpiFlashAddresses(this.getChipFamily()).uartDateReg, 0, 0, delayAfterUs));
+            buffer = buffer.concat(pack("<IIII", getSpiFlashAddresses(this.getChipFamily()).uartDateReg, 0, 0, delayAfterUs));
         }
         await this.checkCommand(ESP_WRITE_REG, buffer);
     }
     async setDataLengths(spiAddresses, mosiBits, misoBits) {
         if (spiAddresses.mosiDlenOffs != -1) {
             // ESP32/32S2/32S3/32C3 has a more sophisticated way to set up "user" commands
-            let SPI_MOSI_DLEN_REG = spiAddresses.regBase + spiAddresses.mosiDlenOffs;
-            let SPI_MISO_DLEN_REG = spiAddresses.regBase + spiAddresses.misoDlenOffs;
+            const SPI_MOSI_DLEN_REG = spiAddresses.regBase + spiAddresses.mosiDlenOffs;
+            const SPI_MISO_DLEN_REG = spiAddresses.regBase + spiAddresses.misoDlenOffs;
             if (mosiBits > 0) {
                 await this.writeRegister(SPI_MOSI_DLEN_REG, mosiBits - 1);
             }
@@ -920,18 +918,18 @@ export class ESPLoader extends EventTarget {
             }
         }
         else {
-            let SPI_DATA_LEN_REG = spiAddresses.regBase + spiAddresses.usr1Offs;
-            let SPI_MOSI_BITLEN_S = 17;
-            let SPI_MISO_BITLEN_S = 8;
-            let mosiMask = mosiBits == 0 ? 0 : mosiBits - 1;
-            let misoMask = misoBits == 0 ? 0 : misoBits - 1;
-            let value = (misoMask << SPI_MISO_BITLEN_S) | (mosiMask << SPI_MOSI_BITLEN_S);
+            const SPI_DATA_LEN_REG = spiAddresses.regBase + spiAddresses.usr1Offs;
+            const SPI_MOSI_BITLEN_S = 17;
+            const SPI_MISO_BITLEN_S = 8;
+            const mosiMask = mosiBits == 0 ? 0 : mosiBits - 1;
+            const misoMask = misoBits == 0 ? 0 : misoBits - 1;
+            const value = (misoMask << SPI_MISO_BITLEN_S) | (mosiMask << SPI_MOSI_BITLEN_S);
             await this.writeRegister(SPI_DATA_LEN_REG, value);
         }
     }
     async waitDone(spiCmdReg, spiCmdUsr) {
         for (let i = 0; i < 10; i++) {
-            let cmdValue = await this.readRegister(spiCmdReg);
+            const cmdValue = await this.readRegister(spiCmdReg);
             if ((cmdValue & spiCmdUsr) == 0) {
                 return;
             }
@@ -947,29 +945,29 @@ export class ESPLoader extends EventTarget {
         // After writing command byte, writes 'data' to MOSI and then
         // reads back 'read_bits' of reply on MISO. Result is a number.
         // SPI_USR register flags
-        let SPI_USR_COMMAND = 1 << 31;
-        let SPI_USR_MISO = 1 << 28;
-        let SPI_USR_MOSI = 1 << 27;
+        const SPI_USR_COMMAND = 1 << 31;
+        const SPI_USR_MISO = 1 << 28;
+        const SPI_USR_MOSI = 1 << 27;
         // SPI registers, base address differs ESP32* vs 8266
-        let spiAddresses = getSpiFlashAddresses(this.getChipFamily());
-        let base = spiAddresses.regBase;
-        let SPI_CMD_REG = base;
-        let SPI_USR_REG = base + spiAddresses.usrOffs;
-        let SPI_USR2_REG = base + spiAddresses.usr2Offs;
-        let SPI_W0_REG = base + spiAddresses.w0Offs;
+        const spiAddresses = getSpiFlashAddresses(this.getChipFamily());
+        const base = spiAddresses.regBase;
+        const SPI_CMD_REG = base;
+        const SPI_USR_REG = base + spiAddresses.usrOffs;
+        const SPI_USR2_REG = base + spiAddresses.usr2Offs;
+        const SPI_W0_REG = base + spiAddresses.w0Offs;
         // SPI peripheral "command" bitmasks for SPI_CMD_REG
-        let SPI_CMD_USR = 1 << 18;
+        const SPI_CMD_USR = 1 << 18;
         // shift values
-        let SPI_USR2_COMMAND_LEN_SHIFT = 28;
+        const SPI_USR2_COMMAND_LEN_SHIFT = 28;
         if (readBits > 32) {
             throw new Error("Reading more than 32 bits back from a SPI flash operation is unsupported");
         }
         if (data.length > 64) {
             throw new Error("Writing more than 64 bytes of data with one SPI command is unsupported");
         }
-        let dataBits = data.length * 8;
-        let oldSpiUsr = await this.readRegister(SPI_USR_REG);
-        let oldSpiUsr2 = await this.readRegister(SPI_USR2_REG);
+        const dataBits = data.length * 8;
+        const oldSpiUsr = await this.readRegister(SPI_USR_REG);
+        const oldSpiUsr2 = await this.readRegister(SPI_USR2_REG);
         let flags = SPI_USR_COMMAND;
         if (readBits > 0) {
             flags |= SPI_USR_MISO;
@@ -984,8 +982,9 @@ export class ESPLoader extends EventTarget {
             await this.writeRegister(SPI_W0_REG, 0); // clear data register before we read it
         }
         else {
-            data.concat(new Array(data.length % 4).fill(0x00)); // pad to 32-bit multiple
-            let words = unpack("I".repeat(Math.floor(data.length / 4)), data);
+            const padLen = (4 - (data.length % 4)) % 4;
+            data = data.concat(new Array(padLen).fill(0x00)); // pad to 32-bit multiple
+            const words = unpack("I".repeat(Math.floor(data.length / 4)), data);
             let nextReg = SPI_W0_REG;
             this.logger.debug(`Words Length: ${words.length}`);
             for (const word of words) {
@@ -996,7 +995,7 @@ export class ESPLoader extends EventTarget {
         }
         await this.writeRegister(SPI_CMD_REG, SPI_CMD_USR);
         await this.waitDone(SPI_CMD_REG, SPI_CMD_USR);
-        let status = await this.readRegister(SPI_W0_REG);
+        const status = await this.readRegister(SPI_W0_REG);
         // restore some SPI controller registers
         await this.writeRegister(SPI_USR_REG, oldSpiUsr);
         await this.writeRegister(SPI_USR2_REG, oldSpiUsr2);
@@ -1004,9 +1003,9 @@ export class ESPLoader extends EventTarget {
     }
     async detectFlashSize() {
         this.logger.log("Detecting Flash Size");
-        let flashId = await this.flashId();
-        let manufacturer = flashId & 0xff;
-        let flashIdLowbyte = (flashId >> 16) & 0xff;
+        const flashId = await this.flashId();
+        const manufacturer = flashId & 0xff;
+        const flashIdLowbyte = (flashId >> 16) & 0xff;
         this.logger.log(`FlashId: ${toHex(flashId)}`);
         this.logger.log(`Flash Manufacturer: ${manufacturer.toString(16)}`);
         this.logger.log(`Flash Device: ${((flashId >> 8) & 0xff).toString(16)}${flashIdLowbyte.toString(16)}`);
@@ -1019,10 +1018,10 @@ export class ESPLoader extends EventTarget {
      *   Provides a workaround for the bootloader erase bug on ESP8266.
      */
     getEraseSize(offset, size) {
-        let sectorsPerBlock = 16;
-        let sectorSize = FLASH_SECTOR_SIZE;
-        let numSectors = Math.floor((size + sectorSize - 1) / sectorSize);
-        let startSector = Math.floor(offset / sectorSize);
+        const sectorsPerBlock = 16;
+        const sectorSize = FLASH_SECTOR_SIZE;
+        const numSectors = Math.floor((size + sectorSize - 1) / sectorSize);
+        const startSector = Math.floor(offset / sectorSize);
         let headSectors = sectorsPerBlock - (startSector % sectorsPerBlock);
         if (numSectors < headSectors) {
             headSectors = numSectors;
@@ -1056,8 +1055,8 @@ export class ESPLoader extends EventTarget {
      * ignore errors.
      */
     async memFinish(entrypoint = 0) {
-        let timeout = this.IS_STUB ? DEFAULT_TIMEOUT : MEM_END_ROM_TIMEOUT;
-        let data = pack("<II", entrypoint == 0 ? 1 : 0, entrypoint);
+        const timeout = this.IS_STUB ? DEFAULT_TIMEOUT : MEM_END_ROM_TIMEOUT;
+        const data = pack("<II", entrypoint == 0 ? 1 : 0, entrypoint);
         return await this.checkCommand(ESP_MEM_END, data, 0, timeout);
     }
     async runStub(skipFlashDetection = false) {
@@ -1068,29 +1067,27 @@ export class ESPLoader extends EventTarget {
             return this;
         }
         // We're transferring over USB, right?
-        let ramBlock = USB_RAM_BLOCK;
+        const ramBlock = USB_RAM_BLOCK;
         // Upload
         this.logger.log("Uploading stub...");
-        for (let field of ["text", "data"]) {
-            if (Object.keys(stub).includes(field)) {
-                let offset = stub[field + "_start"];
-                let length = stub[field].length;
-                let blocks = Math.floor((length + ramBlock - 1) / ramBlock);
-                await this.memBegin(length, blocks, ramBlock, offset);
-                for (let seq of Array(blocks).keys()) {
-                    let fromOffs = seq * ramBlock;
-                    let toOffs = fromOffs + ramBlock;
-                    if (toOffs > length) {
-                        toOffs = length;
-                    }
-                    await this.memBlock(stub[field].slice(fromOffs, toOffs), seq);
+        for (const field of ["text", "data"]) {
+            const fieldData = stub[field];
+            const offset = stub[`${field}_start`];
+            const length = fieldData.length;
+            const blocks = Math.floor((length + ramBlock - 1) / ramBlock);
+            await this.memBegin(length, blocks, ramBlock, offset);
+            for (const seq of Array(blocks).keys()) {
+                const fromOffs = seq * ramBlock;
+                let toOffs = fromOffs + ramBlock;
+                if (toOffs > length) {
+                    toOffs = length;
                 }
+                await this.memBlock(fieldData.slice(fromOffs, toOffs), seq);
             }
         }
-        await this.memFinish(stub["entry"]);
-        let pChar;
+        await this.memFinish(stub.entry);
         const p = await this.readPacket(500);
-        pChar = String.fromCharCode(...p);
+        const pChar = String.fromCharCode(...p);
         if (pChar != "OHAI") {
             throw new Error("Failed to start stub. Unexpected response: " + pChar);
         }
@@ -1109,7 +1106,7 @@ export class ESPLoader extends EventTarget {
             writer.releaseLock();
         }
         catch (err) {
-            console.error("Ignoring release lock error", err);
+            this.logger.error(`Ignoring release lock error: ${err}`);
         }
     }
     async disconnect() {
@@ -1297,8 +1294,8 @@ export class ESPLoader extends EventTarget {
                 try {
                     this.logger.debug(`Reading chunk at 0x${currentAddr.toString(16)}, size: 0x${chunkSize.toString(16)}`);
                     // Send read flash command for this chunk
-                    let pkt = pack("<IIII", currentAddr, chunkSize, 0x1000, 1024);
-                    const [res, _] = await this.checkCommand(ESP_READ_FLASH, pkt);
+                    const pkt = pack("<IIII", currentAddr, chunkSize, 0x1000, 1024);
+                    const [res] = await this.checkCommand(ESP_READ_FLASH, pkt);
                     if (res != 0) {
                         throw new Error("Failed to read memory: " + res);
                     }
@@ -1370,7 +1367,7 @@ export class ESPLoader extends EventTarget {
             }
             currentAddr += chunkSize;
             remainingSize -= chunkSize;
-            this.logger.debug(`Total progress: 0x${allData.length.toString(16)}/0x${size.toString(16)} bytes`);
+            this.logger.debug(`Total progress: 0x${allData.length.toString(16)} from 0x${size.toString(16)} bytes`);
         }
         this.logger.debug(`Successfully read ${allData.length} bytes from flash`);
         return allData;
@@ -1389,17 +1386,17 @@ class EspStubLoader extends ESPLoader {
      * @name memBegin (592)
      * Start downloading an application image to RAM
      */
-    async memBegin(size, blocks, blocksize, offset) {
-        let stub = await getStubCode(this.chipFamily, this.chipRevision);
+    async memBegin(size, _blocks, _blocksize, offset) {
+        const stub = await getStubCode(this.chipFamily, this.chipRevision);
         // Stub may be null for chips without stub support
         if (stub === null) {
-            return;
+            return [0, []];
         }
-        let load_start = offset;
-        let load_end = offset + size;
-        console.log(load_start, load_end);
-        console.log(stub.data_start, stub.data.length, stub.text_start, stub.text.length);
-        for (let [start, end] of [
+        const load_start = offset;
+        const load_end = offset + size;
+        this.logger.debug(`Load range: ${toHex(load_start, 8)}-${toHex(load_end, 8)}`);
+        this.logger.debug(`Stub data: ${toHex(stub.data_start, 8)}, len: ${stub.data.length}, text: ${toHex(stub.text_start, 8)}, len: ${stub.text.length}`);
+        for (const [start, end] of [
             [stub.data_start, stub.data_start + stub.data.length],
             [stub.text_start, stub.text_start + stub.text.length],
         ]) {
@@ -1417,6 +1414,7 @@ class EspStubLoader extends ESPLoader {
                     "Try changing the binary loading address.");
             }
         }
+        return [0, []];
     }
     /**
      * @name getEraseSize