@v5x/cli 0.0.3 → 0.0.5

package/dist/index.js

@@ -117,7 +117,7 @@ var require_picocolors = __commonJS((exports, module) => {
 // package.json
 var package_default = {
   name: "@v5x/cli",
-  version: "0.0.3",
+  version: "0.0.5",
   description: "Command line interface for v5x.",
   license: "MIT",
   type: "module",
@@ -731,6 +731,8 @@ import { join as join2 } from "path";
 import { platform as platform4 } from "os";
 
 class WebSerialPortAdapter extends EventTarget {
+  onconnect = () => {};
+  ondisconnect = () => {};
   _port = null;
   _path;
   _info;
@@ -743,9 +745,13 @@ class WebSerialPortAdapter extends EventTarget {
     this._info = info;
   }
   get readable() {
+    if (!this._readable)
+      throw new Error("Port not open");
     return this._readable;
   }
   get writable() {
+    if (!this._writable)
+      throw new Error("Port not open");
     return this._writable;
   }
   getInfo() {
@@ -805,9 +811,14 @@ class WebSerialPortAdapter extends EventTarget {
     this._writable = null;
     this.dispatchEvent(new Event("disconnect"));
   }
+  async forget() {
+    await this.close();
+  }
 }
 
-class WebSerialAdapter {
+class WebSerialAdapter extends EventTarget {
+  onconnect = () => {};
+  ondisconnect = () => {};
   async _listPortsLinux() {
     const ttys = await readdir2("/sys/class/tty").catch(() => []);
     const ports = [];
@@ -862,35 +873,37 @@ class WebSerialAdapter {
 }
 var serial = new WebSerialAdapter;
 
-// ../serial/src/vex.ts
+// ../serial/src/Vex.ts
 var USER_PROG_CHUNK_SIZE = 4096;
 var USER_FLASH_USR_CODE_START = 58720256;
-// ../serial/src/vex-event.ts
+// ../serial/src/VexEvent.ts
 class VexEventEmitter {
-  handlers;
+  handlerMap;
   constructor() {
-    this.handlers = {};
+    this.handlerMap = new Map;
   }
   on(eventName, listener) {
-    this.handlers[eventName] = this.handlers[eventName] || [];
-    this.handlers[eventName].push(listener);
+    let listeners = this.handlerMap.get(eventName);
+    listeners ??= [];
+    listeners.push(listener);
+    this.handlerMap.set(eventName, listeners);
   }
   remove(eventName, listener) {
-    this.handlers[eventName] = this.handlers[eventName] || [];
-    let index = this.handlers[eventName].indexOf(listener);
+    let listeners = this.handlerMap.get(eventName);
+    listeners ??= [];
+    const index = listeners.indexOf(listener);
     if (index > -1) {
-      this.handlers[eventName].splice(index, 1);
+      listeners.splice(index, 1);
     }
+    this.handlerMap.set(eventName, listeners);
   }
   emit(eventName, data) {
-    (this.handlers[eventName] || []).forEach((callback) => {
+    (this.handlerMap.get(eventName) ?? []).forEach((callback) => {
       callback(data);
     });
   }
   clearListeners() {
-    Object.keys(this.handlers).forEach((e) => {
-      delete this.handlers[e];
-    });
+    this.handlerMap.clear();
   }
 }
 
@@ -913,9 +926,9 @@ class VexEventTarget {
   }
 }
 
-// ../serial/src/vex-packet.ts
-var exports_vex_packet = {};
-__export(exports_vex_packet, {
+// ../serial/src/VexPacket.ts
+var exports_VexPacket = {};
+__export(exports_VexPacket, {
   WriteKeyValueReplyD2HPacket: () => WriteKeyValueReplyD2HPacket,
   WriteKeyValueH2DPacket: () => WriteKeyValueH2DPacket,
   WriteFileReplyD2HPacket: () => WriteFileReplyD2HPacket,
@@ -992,14 +1005,14 @@ __export(exports_vex_packet, {
   ExitFileTransferH2DPacket: () => ExitFileTransferH2DPacket,
   EraseFileReplyD2HPacket: () => EraseFileReplyD2HPacket,
   EraseFileH2DPacket: () => EraseFileH2DPacket,
-  EnableDeshReplyD2HPacket: () => EnableDeshReplyD2HPacket,
+  EnableDashReplyD2HPacket: () => EnableDashReplyD2HPacket,
   EnableDashH2DPacket: () => EnableDashH2DPacket,
-  DisableDeshReplyD2HPacket: () => DisableDeshReplyD2HPacket,
+  DisableDashReplyD2HPacket: () => DisableDashReplyD2HPacket,
   DisableDashH2DPacket: () => DisableDashH2DPacket,
   DeviceBoundPacket: () => DeviceBoundPacket
 });
 
-// ../serial/src/vex-firmware-version.ts
+// ../serial/src/VexFirmwareVersion.ts
 class VexFirmwareVersion {
   major;
   minor;
@@ -1062,70 +1075,45 @@ class VexFirmwareVersion {
   }
 }
 
-// ../serial/src/vex-packet-view.ts
-class PacketView {
-  view;
+// ../serial/src/VexPacketView.ts
+class PacketView extends DataView {
   position = 0;
   littleEndianDefault = true;
   constructor(buffer, offset = 0, length = buffer.byteLength - offset) {
-    this.view = new DataView(buffer, offset, length);
+    super(buffer, offset, length);
   }
   static fromPacket(packet) {
-    let view = new PacketView(packet.data.buffer, packet.data.byteOffset);
+    const view = new PacketView(packet.data.buffer, packet.data.byteOffset);
     view.position = packet.ackIndex + 1;
     return view;
   }
-  get byteLength() {
-    return this.view.byteLength;
-  }
-  get buffer() {
-    return this.view.buffer;
-  }
-  getInt8(byteOffset) {
-    return this.view.getInt8(byteOffset);
-  }
-  getUint8(byteOffset) {
-    return this.view.getUint8(byteOffset);
-  }
-  getInt16(byteOffset, littleEndian) {
-    return this.view.getInt16(byteOffset, littleEndian);
-  }
-  getUint16(byteOffset, littleEndian) {
-    return this.view.getUint16(byteOffset, littleEndian);
-  }
-  getInt32(byteOffset, littleEndian) {
-    return this.view.getInt32(byteOffset, littleEndian);
-  }
-  getUint32(byteOffset, littleEndian) {
-    return this.view.getUint32(byteOffset, littleEndian);
-  }
   nextInt8() {
-    let result = this.getInt8(this.position);
+    const result = this.getInt8(this.position);
     this.position += 1;
     return result;
   }
   nextUint8() {
-    let result = this.getUint8(this.position);
+    const result = this.getUint8(this.position);
     this.position += 1;
     return result;
   }
   nextInt16(littleEndian = this.littleEndianDefault) {
-    let result = this.getInt16(this.position, littleEndian);
+    const result = this.getInt16(this.position, littleEndian);
     this.position += 2;
     return result;
   }
   nextUint16(littleEndian = this.littleEndianDefault) {
-    let result = this.getUint16(this.position, littleEndian);
+    const result = this.getUint16(this.position, littleEndian);
     this.position += 2;
     return result;
   }
   nextInt32(littleEndian = this.littleEndianDefault) {
-    let result = this.getInt32(this.position, littleEndian);
+    const result = this.getInt32(this.position, littleEndian);
     this.position += 4;
     return result;
   }
   nextUint32(littleEndian = this.littleEndianDefault) {
-    let result = this.getUint32(this.position, littleEndian);
+    const result = this.getUint32(this.position, littleEndian);
     this.position += 4;
     return result;
   }
@@ -1138,11 +1126,11 @@ class PacketView {
   }
   nextNTBS(length) {
     let result = "";
-    let lastPosition = this.position;
+    const lastPosition = this.position;
     for (let i = 0;i < length; i++) {
       if (this.byteLength <= this.position)
         break;
-      let g = this.nextUint8();
+      const g = this.nextUint8();
       if (g === 0)
         break;
       result += String.fromCharCode(g);
@@ -1155,7 +1143,7 @@ class PacketView {
     for (let i = 0;i < length; i++) {
       if (this.byteLength <= this.position)
         break;
-      let g = this.nextUint8();
+      const g = this.nextUint8();
       if (g === 0)
         break;
       result += String.fromCharCode(g);
@@ -1163,13 +1151,13 @@ class PacketView {
     return result;
   }
   nextVersion(reverse = false) {
-    let result = VexFirmwareVersion.fromUint8Array(new Uint8Array(this.buffer), this.position, reverse);
+    const result = VexFirmwareVersion.fromUint8Array(new Uint8Array(this.buffer), this.position, reverse);
     this.position += 4;
     return result;
   }
 }
 
-// ../serial/src/vex-crc.ts
+// ../serial/src/VexCRC.ts
 var CRC16TABLE = [
   0,
   4129,
@@ -1430,6 +1418,7 @@ var CRC16TABLE = [
 ];
 
 class CrcGenerator {
+  crc16Table;
   crc32Table;
   static POLYNOMIAL_CRC32 = 79764919;
   static POLYNOMIAL_CRC16 = 4129;
@@ -1449,34 +1438,34 @@ class CrcGenerator {
     return (accumulator & 65535) >>> 0;
   }
   crc32GenTable() {
-    var i;
-    var j;
-    var crc_accumulator;
+    let i;
+    let j;
+    let crcAccumulator;
     for (i = 0;i < 256; i++) {
-      crc_accumulator = i << 24;
+      crcAccumulator = i << 24;
       for (j = 0;j < 8; j++) {
-        if (crc_accumulator & 2147483648)
-          crc_accumulator = crc_accumulator << 1 ^ CrcGenerator.POLYNOMIAL_CRC32;
+        if ((crcAccumulator & 2147483648) !== 0)
+          crcAccumulator = crcAccumulator << 1 ^ CrcGenerator.POLYNOMIAL_CRC32;
         else
-          crc_accumulator = crc_accumulator << 1;
+          crcAccumulator = crcAccumulator << 1;
       }
-      this.crc32Table[i] = crc_accumulator;
+      this.crc32Table[i] = crcAccumulator;
     }
   }
   crc32(buf, initValue) {
     const numberOfBytes = buf.byteLength;
-    let crc_accumulator = initValue;
+    let crcAccumulator = initValue;
     let i;
     let j;
     for (j = 0;j < numberOfBytes; j++) {
-      i = (crc_accumulator >>> 24 ^ buf[j]) & 255;
-      crc_accumulator = (crc_accumulator << 8 ^ this.crc32Table[i]) >>> 0;
+      i = (crcAccumulator >>> 24 ^ buf[j]) & 255;
+      crcAccumulator = (crcAccumulator << 8 ^ this.crc32Table[i]) >>> 0;
     }
-    return (crc_accumulator & 4294967295) >>> 0;
+    return (crcAccumulator & 4294967295) >>> 0;
   }
 }
 
-// ../serial/src/vex-packet.ts
+// ../serial/src/VexPacket.ts
 class PacketEncoder {
   static HEADERS_LENGTH = 4;
   static HEADER_TO_DEVICE = [201, 54, 184, 71];
@@ -1494,7 +1483,7 @@ class PacketEncoder {
   constructor() {
     this.vexVersion = 0;
     this.crcgen = new CrcGenerator;
-    Object.values(exports_vex_packet).forEach((packet) => {
+    Object.values(exports_VexPacket).forEach((packet) => {
       if (packet.prototype instanceof HostBoundPacket) {
         this.allPacketsTable[packet.COMMAND_ID + " " + packet.COMMAND_EXTENDED_ID] = packet;
       }
@@ -1542,9 +1531,9 @@ class PacketEncoder {
       h.set([cmd, ext, data.length], PacketEncoder.HEADERS_LENGTH);
       h.set(data, PacketEncoder.HEADERS_LENGTH + 3);
     } else {
-      const length_msb = (data.length >>> 8 | 128) >>> 0;
-      const length_lsb = (data.length & 255) >>> 0;
-      h.set([cmd, ext, length_msb, length_lsb], PacketEncoder.HEADERS_LENGTH);
+      const lengthMsb = (data.length >>> 8 | 128) >>> 0;
+      const lengthLsb = (data.length & 255) >>> 0;
+      h.set([cmd, ext, lengthMsb, lengthLsb], PacketEncoder.HEADERS_LENGTH);
       h.set(data, PacketEncoder.HEADERS_LENGTH + 4);
     }
     const crc = this.crcgen.crc16(h.subarray(0, buf.byteLength - 2), 0);
@@ -1555,13 +1544,14 @@ class PacketEncoder {
     return !(data[0] !== PacketEncoder.HEADER_TO_HOST[0] || data[1] !== PacketEncoder.HEADER_TO_HOST[1]);
   }
   validateMessageCdc(data) {
-    let message = data.subarray(0, data.byteLength - 2);
-    let lastTwoBytes = (data[data.byteLength - 2] << 8) + data[data.byteLength - 1];
+    const message = data.subarray(0, data.byteLength - 2);
+    const lastTwoBytes = (data[data.byteLength - 2] << 8) + data[data.byteLength - 1];
     return this.crcgen.crc16(message, 0) === lastTwoBytes;
   }
   getPayloadSize(data) {
-    let t = 0, a = data[3];
-    if (128 & a) {
+    let t = 0;
+    let a = data[3];
+    if ((128 & a) !== 0) {
       t = 127 & a;
       a = data[4];
     }
@@ -1580,7 +1570,7 @@ class Packet {
 class DeviceBoundPacket extends Packet {
   constructor(payload) {
     super(new Uint8Array);
-    let me = this.__proto__.constructor;
+    const me = this.__proto__.constructor;
     if (me.COMMAND_EXTENDED_ID === undefined) {
       if (payload === undefined) {
         this.data = Packet.ENCODER.cdcCommand(me.COMMAND_ID);
@@ -1628,7 +1618,8 @@ class UpdateMatchModeH2DPacket extends DeviceBoundPacket {
       case "disabled":
         bit1 = 11;
     }
-    const payload = new Uint8Array(5), view = new DataView(payload.buffer);
+    const payload = new Uint8Array(5);
+    const view = new DataView(payload.buffer);
     payload[0] = (15 & bit1) >>> 0;
     view.setUint32(1, matchClock, true);
     super(payload);
@@ -1678,8 +1669,8 @@ class InitFileTransferH2DPacket extends DeviceBoundPacket {
     view.setUint32(12, operation === 1 /* WRITE */ ? Packet.ENCODER.crcgen.crc32(binary, 0) : 0, true);
     const re = /(?:\.([^.]+))?$/;
     const reResult = re.exec(name);
-    let ext = reResult ? reResult[1] : undefined;
-    ext = ext === undefined ? "" : ext;
+    let ext = reResult != null ? reResult[1] : undefined;
+    ext ??= "";
     ext = ext === "gz" ? "bin" : ext;
     payload.set(new TextEncoder().encode(type ?? ext), 16);
     const timestamp = (Date.now() / 1000 >>> 0) - PacketEncoder.J2000_EPOCH;
@@ -1699,7 +1690,7 @@ class ExitFileTransferH2DPacket extends DeviceBoundPacket {
   static COMMAND_ID = 86;
   static COMMAND_EXTENDED_ID = 18;
   constructor(action) {
-    let payload = new Uint8Array(1);
+    const payload = new Uint8Array(1);
     payload[0] = action;
     super(payload);
   }
@@ -1734,7 +1725,7 @@ class LinkFileH2DPacket extends DeviceBoundPacket {
   static COMMAND_EXTENDED_ID = 21;
   constructor(vendor, fileName, options) {
     const str = new TextEncoder().encode(fileName);
-    let payload = new Uint8Array(26);
+    const payload = new Uint8Array(26);
     payload.set([vendor, options], 0);
     payload.set(str.subarray(0, 23), 2);
     super(payload);
@@ -1745,7 +1736,7 @@ class GetDirectoryFileCountH2DPacket extends DeviceBoundPacket {
   static COMMAND_ID = 86;
   static COMMAND_EXTENDED_ID = 22;
   constructor(vendor) {
-    let payload = new Uint8Array(2);
+    const payload = new Uint8Array(2);
     payload.set([vendor, 0], 0);
     super(payload);
   }
@@ -1755,7 +1746,7 @@ class GetDirectoryEntryH2DPacket extends DeviceBoundPacket {
   static COMMAND_ID = 86;
   static COMMAND_EXTENDED_ID = 23;
   constructor(index) {
-    let payload = new Uint8Array(2);
+    const payload = new Uint8Array(2);
     payload.set([index, 0], 0);
     super(payload);
   }
@@ -1771,7 +1762,8 @@ class LoadFileActionH2DPacket extends DeviceBoundPacket {
     } else {
       fileName = "___s_" + (fileNameOrSlotNumber - 1) + ".bin";
     }
-    let encodedName = new TextEncoder().encode(fileName), payload = new Uint8Array(26);
+    const encodedName = new TextEncoder().encode(fileName);
+    const payload = new Uint8Array(26);
     payload.set([vendor, actionId], 0);
     payload.set(encodedName.subarray(0, 23), 2);
     super(payload);
@@ -1782,8 +1774,8 @@ class GetFileMetadataH2DPacket extends DeviceBoundPacket {
   static COMMAND_ID = 86;
   static COMMAND_EXTENDED_ID = 25;
   constructor(vendor, fileName, options) {
-    let encodedName = new TextEncoder().encode(fileName);
-    let payload = new Uint8Array(26);
+    const encodedName = new TextEncoder().encode(fileName);
+    const payload = new Uint8Array(26);
     payload.set([vendor, options], 0);
     payload.set(encodedName.subarray(0, 23), 2);
     super(payload);
@@ -1794,15 +1786,15 @@ class SetFileMetadataH2DPacket extends DeviceBoundPacket {
   static COMMAND_ID = 86;
   static COMMAND_EXTENDED_ID = 26;
   constructor(vendor, fileName, fileInfo, options) {
-    let encodedName = new TextEncoder().encode(fileName);
-    let encodedType = new TextEncoder().encode(fileInfo.type);
-    let payload = new Uint8Array(42);
-    let view = new DataView(payload.buffer);
+    const encodedName = new TextEncoder().encode(fileName);
+    const encodedType = new TextEncoder().encode(fileInfo.type);
+    const payload = new Uint8Array(42);
+    const view = new DataView(payload.buffer);
     view.setUint8(0, vendor);
     view.setUint8(1, options);
     view.setUint32(2, fileInfo.loadAddress, true);
     payload.set(encodedType.subarray(0, 4), 6);
-    let timestamp = fileInfo.timestamp - PacketEncoder.J2000_EPOCH + 100;
+    const timestamp = fileInfo.timestamp - PacketEncoder.J2000_EPOCH + 100;
     view.setUint32(10, timestamp, true);
     payload.set(fileInfo.version.toUint8Array(), 14);
     payload.set(encodedName.subarray(0, 23), 18);
@@ -1814,8 +1806,8 @@ class EraseFileH2DPacket extends DeviceBoundPacket {
   static COMMAND_ID = 86;
   static COMMAND_EXTENDED_ID = 27;
   constructor(vendor, fileName) {
-    let encodedName = new TextEncoder().encode(fileName);
-    let payload = new Uint8Array(26);
+    const encodedName = new TextEncoder().encode(fileName);
+    const payload = new Uint8Array(26);
     payload.set([vendor, 128], 0);
     payload.set(encodedName.subarray(0, 23), 2);
     super(payload);
@@ -1826,8 +1818,8 @@ class GetProgramSlotInfoH2DPacket extends DeviceBoundPacket {
   static COMMAND_ID = 86;
   static COMMAND_EXTENDED_ID = 28;
   constructor(vendor, fileName) {
-    let encodedName = new TextEncoder().encode(fileName);
-    let payload = new Uint8Array(26);
+    const encodedName = new TextEncoder().encode(fileName);
+    const payload = new Uint8Array(26);
     payload.set([vendor, 0], 0);
     payload.set(encodedName.subarray(0, 23), 2);
     super(payload);
@@ -1838,7 +1830,7 @@ class FileClearUpH2DPacket extends DeviceBoundPacket {
   static COMMAND_ID = 86;
   static COMMAND_EXTENDED_ID = 30;
   constructor(vendor) {
-    let payload = new Uint8Array(2);
+    const payload = new Uint8Array(2);
     payload.set([vendor, 0], 0);
     super(payload);
   }
@@ -1848,7 +1840,7 @@ class FileFormatH2DPacket extends DeviceBoundPacket {
   static COMMAND_ID = 86;
   static COMMAND_EXTENDED_ID = 31;
   constructor() {
-    let payload = new Uint8Array(4);
+    const payload = new Uint8Array(4);
     payload.set([68, 67, 66, 65], 0);
     super(payload);
   }
@@ -1895,8 +1887,8 @@ class ReadLogPageH2DPacket extends DeviceBoundPacket {
   static COMMAND_ID = 86;
   static COMMAND_EXTENDED_ID = 37;
   constructor(offset, count) {
-    let payload = new Uint8Array(8);
-    let view = new DataView(payload.buffer);
+    const payload = new Uint8Array(8);
+    const view = new DataView(payload.buffer);
     view.setUint32(0, offset, true);
     view.setUint32(4, count, true);
     super(payload);
@@ -1915,13 +1907,13 @@ class GetUserDataH2DPacket extends DeviceBoundPacket {
   static COMMAND_ID = 86;
   static COMMAND_EXTENDED_ID = 39;
   constructor(e) {
-    let len = e?.length || 0;
+    let len = e?.length ?? 0;
     if (len > 244)
       len = 244;
-    let payload = new Uint8Array(2 + len);
+    const payload = new Uint8Array(2 + len);
     payload[0] = 1;
     payload[1] = len;
-    payload.set(e || new Uint8Array(0), 2);
+    payload.set(e ?? new Uint8Array(0), 2);
     super(payload);
   }
 }
@@ -1930,7 +1922,7 @@ class ScreenCaptureH2DPacket extends DeviceBoundPacket {
   static COMMAND_ID = 86;
   static COMMAND_EXTENDED_ID = 40;
   constructor(e) {
-    let payload = new Uint8Array(1);
+    const payload = new Uint8Array(1);
     payload[0] = e;
     super(payload);
   }
@@ -1940,8 +1932,8 @@ class SendDashTouchH2DPacket extends DeviceBoundPacket {
   static COMMAND_ID = 86;
   static COMMAND_EXTENDED_ID = 42;
   constructor(x, y, press) {
-    let payload = new Uint8Array(6);
-    let view = new DataView(payload.buffer);
+    const payload = new Uint8Array(6);
+    const view = new DataView(payload.buffer);
     view.setUint16(0, x, true);
     view.setUint16(2, y, true);
     view.setUint16(4, press ? 1 : 0, true);
@@ -1953,7 +1945,7 @@ class SelectDashH2DPacket extends DeviceBoundPacket {
   static COMMAND_ID = 86;
   static COMMAND_EXTENDED_ID = 43;
   constructor(screen, port) {
-    let payload = new Uint8Array(2);
+    const payload = new Uint8Array(2);
     payload[0] = screen;
     payload[1] = port;
     super(payload);
@@ -1967,7 +1959,7 @@ class EnableDashH2DPacket extends DeviceBoundPacket {
     if (unknown1 === undefined) {
       super(undefined);
     } else {
-      let payload = new Uint8Array(1);
+      const payload = new Uint8Array(1);
       payload[0] = unknown1;
       super(payload);
     }
@@ -1986,7 +1978,7 @@ class ReadKeyValueH2DPacket extends DeviceBoundPacket {
   static COMMAND_ID = 86;
   static COMMAND_EXTENDED_ID = 46;
   constructor(key) {
-    let payload = new Uint8Array(32);
+    const payload = new Uint8Array(32);
     payload.set(new TextEncoder().encode(key), 0);
     super(payload);
   }
@@ -2000,7 +1992,7 @@ class WriteKeyValueH2DPacket extends DeviceBoundPacket {
     const strv = new TextEncoder().encode(value);
     if (strk.byteLength > 31)
       strk = strk.subarray(0, 31);
-    let payload = new Uint8Array(strk.length + strv.length + 20);
+    const payload = new Uint8Array(strk.length + strv.length + 20);
     payload.set(strk, 0);
     payload.set(strv, strk.length + 1);
     super(payload);
@@ -2032,7 +2024,7 @@ class FactoryEnableH2DPacket extends DeviceBoundPacket {
   static COMMAND_ID = 86;
   static COMMAND_EXTENDED_ID = 255;
   constructor() {
-    let payload = new Uint8Array(4);
+    const payload = new Uint8Array(4);
     payload.set([77, 76, 75, 74], 0);
     super(payload);
   }
@@ -2120,7 +2112,7 @@ class MatchStatusReplyD2HPacket extends HostBoundPacket {
   constructor(data) {
     super(data);
     const dataView = PacketView.fromPacket(this);
-    let n = this.ackIndex;
+    const n = this.ackIndex;
     this.rssi = dataView.nextInt8();
     this.systemStatusBits = dataView.nextUint16();
     this.radioStatusBits = dataView.nextUint16();
@@ -2186,10 +2178,10 @@ class ReadFileReplyD2HPacket extends HostBoundPacket {
   constructor(data) {
     super(data);
     const dataView = PacketView.fromPacket(this);
-    let n = this.ackIndex;
+    const n = this.ackIndex;
     this.addr = dataView.getUint32(n, true);
     this.length = this.payloadSize - 7;
-    this.buf = this.data.slice(n + 4, n + 4 + this.length);
+    this.buf = data.slice(n + 4, n + 4 + this.length);
   }
   static isValidPacket(data, n) {
     return data[4] === 4 ? data[n + 1] === 118 /* CDC2_ACK */ : true;
@@ -2309,9 +2301,10 @@ class GetSystemFlagsReplyD2HPacket extends HostBoundPacket {
     this.radioSearching = false;
     this.currentProgram = 0;
     this.flags = dataView.nextUint32();
-    let hasPartner = (8192 & this.flags) !== 0;
-    let hasRadio = (1536 & this.flags) === 1536;
-    let byte1 = dataView.nextUint8(), byte2 = dataView.nextUint8();
+    const hasPartner = (8192 & this.flags) !== 0;
+    const hasRadio = (1536 & this.flags) === 1536;
+    const byte1 = dataView.nextUint8();
+    const byte2 = dataView.nextUint8();
     if (this.payloadSize === 11) {
       this.battery = 8 * (byte1 & 15);
       if ((this.flags & 256) !== 0 || hasRadio)
@@ -2322,13 +2315,13 @@ class GetSystemFlagsReplyD2HPacket extends HostBoundPacket {
       if (hasPartner)
         this.partnerControllerBatteryPercent = 8 * (byte2 >> 4 & 15);
       this.currentProgram = dataView.nextUint8();
-      if (this.battery && this.battery > 100)
+      if (this.battery != null && this.battery > 100)
         this.battery = 100;
-      if (this.controllerBatteryPercent && this.controllerBatteryPercent > 100)
+      if (this.controllerBatteryPercent != null && this.controllerBatteryPercent > 100)
         this.controllerBatteryPercent = 100;
-      if (this.radioQuality && this.radioQuality > 100)
+      if (this.radioQuality != null && this.radioQuality > 100)
         this.radioQuality = 100;
-      if (this.partnerControllerBatteryPercent && this.partnerControllerBatteryPercent > 100)
+      if (this.partnerControllerBatteryPercent != null && this.partnerControllerBatteryPercent > 100)
         this.partnerControllerBatteryPercent = 100;
     }
   }
@@ -2453,8 +2446,8 @@ class ReadLogPageReplyD2HPacket extends HostBoundPacket {
   constructor(data) {
     super(data);
     const dataView = PacketView.fromPacket(this);
-    let n = this.ackIndex;
-    let size = dataView.nextUint8();
+    const n = this.ackIndex;
+    const size = dataView.nextUint8();
     this.offset = dataView.nextUint32();
     this.count = dataView.nextUint16();
     this.entries = [];
@@ -2483,7 +2476,7 @@ class GetRadioStatusReplyD2HPacket extends HostBoundPacket {
   constructor(data) {
     super(data);
     const dataView = PacketView.fromPacket(this);
-    let n = this.ackIndex;
+    const n = this.ackIndex;
     this.device = dataView.nextUint8();
     this.quality = dataView.nextUint16();
     this.strength = dataView.nextInt16();
@@ -2512,12 +2505,12 @@ class SelectDashReplyD2HPacket extends HostBoundPacket {
   static COMMAND_EXTENDED_ID = 43;
 }
 
-class EnableDeshReplyD2HPacket extends HostBoundPacket {
+class EnableDashReplyD2HPacket extends HostBoundPacket {
   static COMMAND_ID = 86;
   static COMMAND_EXTENDED_ID = 44;
 }
 
-class DisableDeshReplyD2HPacket extends HostBoundPacket {
+class DisableDashReplyD2HPacket extends HostBoundPacket {
   static COMMAND_ID = 86;
   static COMMAND_EXTENDED_ID = 45;
 }
@@ -2549,12 +2542,12 @@ class GetSlot1to4InfoReplyD2HPacket extends HostBoundPacket {
     this.slotFlags = dataView.nextUint8();
     this.slots = [];
     for (let i = 0;i < 4; i++) {
-      let hasData = (this.slotFlags & Math.pow(2, start - 1 + i)) !== 0;
+      const hasData = (this.slotFlags & Math.pow(2, start - 1 + i)) !== 0;
       if (!hasData)
         continue;
-      let iconNum = dataView.nextUint16();
-      let nameLen = dataView.nextUint8();
-      let name = dataView.nextString(nameLen);
+      const iconNum = dataView.nextUint16();
+      const nameLen = dataView.nextUint8();
+      const name = dataView.nextString(nameLen);
       this.slots.push({
         slot: start + i,
         icon: iconNum,
@@ -2591,7 +2584,7 @@ class FactoryEnableReplyD2HPacket extends HostBoundPacket {
   static COMMAND_EXTENDED_ID = 255;
 }
 
-// ../serial/src/vex-connection.ts
+// ../serial/src/VexConnection.ts
 var thePacketEncoder = PacketEncoder.getInstance();
 
 class VexSerialConnection extends VexEventTarget {
@@ -2600,25 +2593,17 @@ class VexSerialConnection extends VexEventTarget {
   reader;
   port;
   serial;
-  isClosing = false;
   callbacksQueue = [];
   get isConnected() {
-    return this.port && this.reader && this.writer ? true : false;
+    return this.port !== undefined && this.reader !== undefined && this.writer !== undefined;
   }
   constructor(serial2) {
     super();
     this.serial = serial2;
   }
   async close() {
-    if (this.isClosing)
-      return;
     if (!this.isConnected)
       return;
-    this.isClosing = true;
-    for (const callbackInfo of this.callbacksQueue) {
-      clearTimeout(callbackInfo.timeout);
-    }
-    this.callbacksQueue = [];
     try {
       await this.writer?.close();
       this.writer = undefined;
@@ -2626,8 +2611,8 @@ class VexSerialConnection extends VexEventTarget {
     try {
       await this.reader?.cancel();
       try {
-        while (this.reader) {
-          const { value, done } = await this.reader.read();
+        while (this.reader != null) {
+          const { done } = await this.reader.read();
           if (done)
             break;
         }
@@ -2641,37 +2626,36 @@ class VexSerialConnection extends VexEventTarget {
     } catch (e) {
       console.warn("Close port error.", e);
     } finally {
-      this.isClosing = false;
       this.emit("disconnected", undefined);
     }
   }
   async open(use = 0, askUser = true) {
-    if (this.port)
+    if (this.port !== undefined)
       throw new Error("Already connected.");
     let port;
     if (use !== undefined) {
-      let ports = (await this.serial.getPorts()).filter((p) => {
-        let info = p.getInfo();
+      const ports = (await this.serial.getPorts()).filter((p) => {
+        const info = p.getInfo();
         return this.filters.find((f) => (f.usbVendorId === undefined || f.usbVendorId === info.usbVendorId) && (f.usbProductId === undefined || f.usbProductId === info.usbProductId));
-      }).filter((e) => !e.readable);
+      }).filter((e) => e.readable !== null);
       port = ports[use];
     }
-    if (!port && askUser) {
+    if (port == null && askUser) {
       try {
         port = await this.serial.requestPort({ filters: this.filters });
       } catch (e) {
-        throw new Error("No valid port selected.");
+        console.warn("No valid port selected.");
       }
     }
-    if (!port)
+    if (port == null)
       return;
-    if (port.readable)
+    if (port.readable != null)
       return false;
     try {
       await port.open({ baudRate: 115200 });
       this.port = port;
-      this.port.addEventListener("disconnect", async () => {
-        await this.close();
+      this.port.addEventListener("disconnect", () => {
+        this.close();
       });
       this.emit("connected", undefined);
       this.writer = this.port.writable.getWriter();
@@ -2685,15 +2669,15 @@ class VexSerialConnection extends VexEventTarget {
   writeData(rawData, resolve, timeout = 1000) {
     this.writeDataAsync(rawData, timeout).then(resolve);
   }
-  writeDataAsync(rawData, timeout = 1000) {
-    return new Promise(async (done) => {
+  async writeDataAsync(rawData, timeout = 1000) {
+    return await new Promise((resolve) => {
       if (this.writer === undefined) {
-        done(255 /* CDC2_NACK */);
+        resolve(255 /* CDC2_NACK */);
         return;
       }
-      let data = rawData instanceof DeviceBoundPacket ? rawData.data : rawData;
-      let cb = {
-        callback: done,
+      const data = rawData instanceof DeviceBoundPacket ? rawData.data : rawData;
+      const cb = {
+        callback: resolve,
         timeout: setTimeout(() => {
           this.callbacksQueue.shift()?.callback(256 /* TIMEOUT */);
         }, timeout),
@@ -2701,19 +2685,16 @@ class VexSerialConnection extends VexEventTarget {
         wantedCommandExId: rawData instanceof DeviceBoundPacket ? rawData.constructor.COMMAND_EXTENDED_ID : undefined
       };
       this.callbacksQueue.push(cb);
-      try {
-        this.writer.write(data).then(() => {
-          logData(data, 100);
-        });
-      } catch (error) {
+      this.writer.write(data).then(() => {
+        logData(data, 100);
+      }).catch(() => {
         this.callbacksQueue.splice(this.callbacksQueue.indexOf(cb), 1);
-        done(257 /* WRITE_ERROR */);
-        return;
-      }
+        resolve(257 /* WRITE_ERROR */);
+      });
     });
   }
   async readData(cache, expectedSize) {
-    if (!this.reader)
+    if (this.reader == null)
       throw new Error("No reader");
     while (cache.byteLength < expectedSize) {
       const { value: readData, done: isDone } = await this.reader.read();
@@ -2724,7 +2705,8 @@ class VexSerialConnection extends VexEventTarget {
     return cache;
   }
   async startReader() {
-    let cache = new Uint8Array([]), sliceIdx = 0;
+    let cache = new Uint8Array([]);
+    let sliceIdx = 0;
     for (;; )
       try {
         cache = await this.readData(cache, 5);
@@ -2737,7 +2719,7 @@ class VexSerialConnection extends VexEventTarget {
         cache = await this.readData(cache, totalSize);
         sliceIdx = totalSize + 1;
         const cmdId = cache[2];
-        const hasExtId = cmdId == 88 || cmdId == 86;
+        const hasExtId = cmdId === 88 || cmdId === 86;
         const cmdExId = hasExtId ? cache[n] : undefined;
         const ack = cache[n + 1];
         if (hasExtId) {
@@ -2748,7 +2730,7 @@ class VexSerialConnection extends VexEventTarget {
         let wantedCmdId;
         let wantedCmdExId;
         let tryIdx = 0;
-        while (callbackInfo = this.callbacksQueue[tryIdx++]) {
+        while ((callbackInfo = this.callbacksQueue[tryIdx++]) !== null) {
           wantedCmdId = callbackInfo?.wantedCommandId;
           wantedCmdExId = callbackInfo?.wantedCommandExId;
           if (wantedCmdId !== undefined && wantedCmdId !== cmdId || wantedCmdExId !== undefined && wantedCmdExId !== cmdExId) {
@@ -2760,13 +2742,13 @@ class VexSerialConnection extends VexEventTarget {
           console.warn("Unexpected command", cmdId, cmdExId, ack);
           continue;
         }
-        let data = cache.slice(0, sliceIdx);
-        let packageType = thePacketEncoder.allPacketsTable[wantedCmdId + " " + wantedCmdExId];
-        if (wantedCmdId === undefined && wantedCmdExId === undefined || packageType === undefined) {
-          callbackInfo.callback(data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength));
+        const data = cache.slice(0, sliceIdx);
+        const PackageType = thePacketEncoder.allPacketsTable[wantedCmdId + " " + wantedCmdExId];
+        if (wantedCmdId === undefined && wantedCmdExId === undefined || PackageType === undefined) {
+          callbackInfo.callback(data);
         } else {
-          if (!hasExtId || packageType.isValidPacket(data, n)) {
-            callbackInfo.callback(new packageType(data));
+          if (!hasExtId || PackageType.isValidPacket(data, n)) {
+            callbackInfo.callback(new PackageType(data));
           } else {
             console.warn("ack", ack);
             callbackInfo.callback(ack);
@@ -2775,8 +2757,6 @@ class VexSerialConnection extends VexEventTarget {
         clearTimeout(callbackInfo.timeout);
         this.callbacksQueue.splice(tryIdx - 1, 1);
       } catch (e) {
-        if (this.isClosing)
-          break;
         console.warn("Read error.", e, cache);
         await this.close();
         break;
@@ -2785,11 +2765,11 @@ class VexSerialConnection extends VexEventTarget {
       }
   }
   async query1() {
-    let result = await this.writeDataAsync(new Query1H2DPacket, 100);
+    const result = await this.writeDataAsync(new Query1H2DPacket, 100);
     return result instanceof Query1ReplyD2HPacket ? result : null;
   }
   async getSystemVersion() {
-    let result = await this.writeDataAsync(new SystemVersionH2DPacket);
+    const result = await this.writeDataAsync(new SystemVersionH2DPacket);
     return result instanceof SystemVersionReplyD2HPacket ? result.version : null;
   }
 }
@@ -2801,70 +2781,76 @@ class V5SerialConnection extends VexSerialConnection {
     { usbVendorId: 10376, usbProductId: 1283 /* V5_CONTROLLER */ }
   ];
   async getDeviceStatus() {
-    let result = await this.writeDataAsync(new GetDeviceStatusH2DPacket);
+    const result = await this.writeDataAsync(new GetDeviceStatusH2DPacket);
     return result instanceof GetDeviceStatusReplyD2HPacket ? result : null;
   }
   async getRadioStatus() {
-    let result = await this.writeDataAsync(new GetRadioStatusH2DPacket);
+    const result = await this.writeDataAsync(new GetRadioStatusH2DPacket);
     return result instanceof GetRadioStatusReplyD2HPacket ? result : null;
   }
   async getSystemFlags() {
-    let result = await this.writeDataAsync(new GetSystemFlagsH2DPacket);
+    const result = await this.writeDataAsync(new GetSystemFlagsH2DPacket);
     return result instanceof GetSystemFlagsReplyD2HPacket ? result : null;
   }
   async getSystemStatus(timeout = 1000) {
-    let result = await this.writeDataAsync(new GetSystemStatusH2DPacket, timeout);
+    const result = await this.writeDataAsync(new GetSystemStatusH2DPacket, timeout);
     return result instanceof GetSystemStatusReplyD2HPacket ? result : null;
   }
   async getMatchStatus() {
-    let result = await this.writeDataAsync(new GetMatchStatusH2DPacket);
+    const result = await this.writeDataAsync(new GetMatchStatusH2DPacket);
     return result instanceof MatchStatusReplyD2HPacket ? result : null;
   }
   async uploadProgramToDevice(iniConfig, binFileBuf, coldFileBuf, progressCallback) {
-    let iniFileBuffer = new TextEncoder().encode(iniConfig.createIni());
-    let basename = iniConfig.baseName;
-    let iniRequest = {
+    const iniFileBuffer = new TextEncoder().encode(iniConfig.createIni());
+    const basename = iniConfig.baseName;
+    const iniRequest = {
       filename: basename + ".ini",
       buf: iniFileBuffer,
       downloadTarget: 1 /* FILE_TARGET_QSPI */,
       vid: 1 /* USER */,
       autoRun: false
     };
-    let r1 = await this.uploadFileToDevice(iniRequest, (current, total) => progressCallback("INI", current, total));
+    const r1 = await this.uploadFileToDevice(iniRequest, (current, total) => {
+      progressCallback("INI", current, total);
+    });
     if (!r1)
       return false;
-    let coldRequest = coldFileBuf !== undefined ? {
+    const coldRequest = coldFileBuf !== undefined ? {
       filename: basename + "_lib.bin",
       buf: coldFileBuf,
       downloadTarget: 1 /* FILE_TARGET_QSPI */,
       vid: 24,
       autoRun: false
     } : undefined;
-    if (coldRequest) {
-      let r2 = await this.uploadFileToDevice(coldRequest, (current, total) => progressCallback("COLD", current, total));
+    if (coldRequest != null) {
+      const r2 = await this.uploadFileToDevice(coldRequest, (current, total) => {
+        progressCallback("COLD", current, total);
+      });
       if (!r2)
         return;
     }
-    let binRequest = {
+    const binRequest = {
       filename: basename + ".bin",
       buf: binFileBuf,
       downloadTarget: 1 /* FILE_TARGET_QSPI */,
       vid: 1 /* USER */,
-      loadAddress: coldFileBuf ? 125829120 : undefined,
+      loadAddress: coldFileBuf != null ? 125829120 : undefined,
       autoRun: iniConfig.autorun,
       linkedFile: coldRequest
     };
-    let r3 = await this.uploadFileToDevice(binRequest, (current, total) => progressCallback("BIN", current, total));
+    const r3 = await this.uploadFileToDevice(binRequest, (current, total) => {
+      progressCallback("BIN", current, total);
+    });
     return r3;
   }
   async downloadFileToHost(request, downloadTarget = 1 /* FILE_TARGET_QSPI */, progressCallback) {
-    let { filename, vendor, loadAddress, size } = request;
+    const { filename, vendor, loadAddress, size } = request;
     let nextAddress = loadAddress ?? USER_FLASH_USR_CODE_START;
-    let p1 = await this.writeDataAsync(new InitFileTransferH2DPacket(2 /* READ */, downloadTarget, vendor, 0 /* NONE */, new Uint8Array, nextAddress, filename, ""));
+    const p1 = await this.writeDataAsync(new InitFileTransferH2DPacket(2 /* READ */, downloadTarget, vendor, 0 /* NONE */, new Uint8Array, nextAddress, filename, ""));
     if (!(p1 instanceof InitFileTransferReplyD2HPacket))
       throw new Error("InitFileTransferH2DPacket failed");
-    let fileSize = size ?? p1.fileSize;
-    let bufferChunkSize = p1.windowSize > 0 && p1.windowSize <= USER_PROG_CHUNK_SIZE ? p1.windowSize : USER_PROG_CHUNK_SIZE;
+    const fileSize = size ?? p1.fileSize;
+    const bufferChunkSize = p1.windowSize > 0 && p1.windowSize <= USER_PROG_CHUNK_SIZE ? p1.windowSize : USER_PROG_CHUNK_SIZE;
     let bufferOffset = 0;
     let fileBuf = new Uint8Array(fileSize + bufferChunkSize);
     let lastBlock = false;
@@ -2872,16 +2858,16 @@ class V5SerialConnection extends VexSerialConnection {
       if (fileSize <= bufferOffset + bufferChunkSize) {
         lastBlock = true;
       }
-      let p2 = await this.writeDataAsync(new ReadFileH2DPacket(nextAddress, bufferChunkSize), 3000);
+      const p2 = await this.writeDataAsync(new ReadFileH2DPacket(nextAddress, bufferChunkSize), 3000);
       if (!(p2 instanceof ReadFileReplyD2HPacket))
         throw new Error("ReadFileReplyD2HPacket failed");
       fileBuf.set(new Uint8Array(p2.buf), bufferOffset);
-      if (progressCallback)
+      if (progressCallback != null)
         progressCallback(bufferOffset, fileSize);
       bufferOffset += bufferChunkSize;
       nextAddress += bufferChunkSize;
     }
-    let p3 = await this.writeDataAsync(new ExitFileTransferH2DPacket(3 /* EXIT_HALT */), 30000);
+    await this.writeDataAsync(new ExitFileTransferH2DPacket(3 /* EXIT_HALT */), 30000);
     fileBuf = fileBuf.slice(0, fileSize);
     return fileBuf;
   }
@@ -2903,74 +2889,76 @@ class V5SerialConnection extends VexSerialConnection {
     vendor = vendor ?? 1 /* USER */;
     let nextAddress = loadAddress ?? USER_FLASH_USR_CODE_START;
     console.log("init file transfer", filename);
-    let p1 = await this.writeDataAsync(new InitFileTransferH2DPacket(1 /* WRITE */, downloadTarget, vendor, 1 /* OVERWRITE */, buf, nextAddress, filename, exttype));
+    const p1 = await this.writeDataAsync(new InitFileTransferH2DPacket(1 /* WRITE */, downloadTarget, vendor, 1 /* OVERWRITE */, buf, nextAddress, filename, exttype));
     if (!(p1 instanceof InitFileTransferReplyD2HPacket))
       throw new Error("InitFileTransferH2DPacket failed");
     console.log(p1);
     if (linkedFile !== undefined) {
-      let p3 = await this.writeDataAsync(new LinkFileH2DPacket(linkedFile.vendor ?? 1 /* USER */, linkedFile.filename, 0), 1e4);
+      const p3 = await this.writeDataAsync(new LinkFileH2DPacket(linkedFile.vendor ?? 1 /* USER */, linkedFile.filename, 0), 1e4);
       if (!(p3 instanceof LinkFileReplyD2HPacket))
         throw new Error("LinkFileH2DPacket failed");
     }
-    let bufferChunkSize = p1.windowSize > 0 && p1.windowSize <= USER_PROG_CHUNK_SIZE ? p1.windowSize : USER_PROG_CHUNK_SIZE;
+    const bufferChunkSize = p1.windowSize > 0 && p1.windowSize <= USER_PROG_CHUNK_SIZE ? p1.windowSize : USER_PROG_CHUNK_SIZE;
     let bufferOffset = 0;
     let lastBlock = false;
     while (!lastBlock) {
-      var tmpbuf;
+      let tmpbuf;
       if (buf.byteLength - bufferOffset > bufferChunkSize) {
         tmpbuf = buf.subarray(bufferOffset, bufferOffset + bufferChunkSize);
       } else {
-        let length = (buf.byteLength - bufferOffset + 3) / 4 >>> 0;
+        const length = (buf.byteLength - bufferOffset + 3) / 4 >>> 0;
         tmpbuf = new Uint8Array(length * 4);
         tmpbuf.set(buf.subarray(bufferOffset, buf.byteLength));
         lastBlock = true;
       }
-      let p2 = await this.writeDataAsync(new WriteFileH2DPacket(nextAddress, tmpbuf), 3000);
+      const p2 = await this.writeDataAsync(new WriteFileH2DPacket(nextAddress, tmpbuf), 3000);
       if (!(p2 instanceof WriteFileReplyD2HPacket))
         throw new Error("WriteFileReplyD2HPacket failed");
-      if (progressCallback)
+      if (progressCallback != null)
         progressCallback(bufferOffset, buf.byteLength);
       bufferOffset += bufferChunkSize;
       nextAddress += bufferChunkSize;
     }
-    let p4 = await this.writeDataAsync(new ExitFileTransferH2DPacket(autoRun ? 1 /* EXIT_RUN */ : 3 /* EXIT_HALT */), 30000);
+    const p4 = await this.writeDataAsync(new ExitFileTransferH2DPacket(autoRun ? 1 /* EXIT_RUN */ : 3 /* EXIT_HALT */), 30000);
     return p4 instanceof ExitFileTransferReplyD2HPacket;
   }
   async setMatchMode(mode) {
-    let result = await this.writeDataAsync(new UpdateMatchModeH2DPacket(mode, 0));
+    const result = await this.writeDataAsync(new UpdateMatchModeH2DPacket(mode, 0));
     return result instanceof MatchModeReplyD2HPacket ? result : null;
   }
   async loadProgram(value) {
-    let result = await this.writeDataAsync(new LoadFileActionH2DPacket(1 /* USER */, 0 /* RUN */, value));
+    const result = await this.writeDataAsync(new LoadFileActionH2DPacket(1 /* USER */, 0 /* RUN */, value));
     return result instanceof LoadFileActionReplyD2HPacket ? result : null;
   }
   async stopProgram() {
-    let result = await this.writeDataAsync(new LoadFileActionH2DPacket(1 /* USER */, 128 /* STOP */, ""));
+    const result = await this.writeDataAsync(new LoadFileActionH2DPacket(1 /* USER */, 128 /* STOP */, ""));
     return result instanceof LoadFileActionReplyD2HPacket ? result : null;
   }
   async mockTouch(x, y, press) {
-    let result = await this.writeDataAsync(new SendDashTouchH2DPacket(x, y, press));
+    const result = await this.writeDataAsync(new SendDashTouchH2DPacket(x, y, press));
+    return result instanceof SendDashTouchReplyD2HPacket ? result : null;
+  }
+  async openScreen(screen, port) {
+    const result = await this.writeDataAsync(new SelectDashH2DPacket(screen, port));
     return result instanceof SendDashTouchReplyD2HPacket ? result : null;
   }
 }
 function logData(data, limitedSize) {
   if (data === undefined)
     return;
-  limitedSize || (limitedSize = data.length);
+  limitedSize ||= data.length;
   let a = "";
   for (let n = 0;n < data.length && n < limitedSize; n++)
     a += ("00" + data[n].toString(16)).substr(-2, 2) + " ";
   limitedSize < data.length && (a += " ... ");
 }
 function binaryArrayJoin(left, right) {
-  const leftSize = left ? left.byteLength : 0;
-  const rightSize = right ? right.byteLength : 0;
+  const leftSize = left != null ? left.byteLength : 0;
+  const rightSize = right != null ? right.byteLength : 0;
   const all = new Uint8Array(leftSize + rightSize);
-  return all.length === 0 ? new Uint8Array : (left && all.set(left instanceof Uint8Array ? left : new Uint8Array(left), 0), right && all.set(right instanceof Uint8Array ? right : new Uint8Array(right), leftSize), all);
+  return all.length === 0 ? new Uint8Array : (left != null && all.set(new Uint8Array(left), 0), right != null && all.set(new Uint8Array(right), leftSize), all);
 }
-// ../../node_modules/.bun/unzipit@2.0.1/node_modules/unzipit/dist/unzipit.module.js
-var _a;
-var _b;
+// ../../node_modules/.bun/unzipit@1.4.3/node_modules/unzipit/dist/unzipit.module.js
 function readBlobAsArrayBuffer(blob) {
   if (blob.arrayBuffer) {
     return blob.arrayBuffer();
@@ -2994,7 +2982,7 @@ function isBlob(v) {
 function isSharedArrayBuffer(b) {
   return typeof SharedArrayBuffer !== "undefined" && b instanceof SharedArrayBuffer;
 }
-var isNode = typeof process !== "undefined" && !!(process === null || process === undefined ? undefined : process.versions) && typeof ((_a = process === null || process === undefined ? undefined : process.versions) === null || _a === undefined ? undefined : _a.node) !== "undefined" && typeof ((_b = process === null || process === undefined ? undefined : process.versions) === null || _b === undefined ? undefined : _b.electron) === "undefined";
+var isNode = typeof process !== "undefined" && process.versions && typeof process.versions.node !== "undefined" && typeof process.versions.electron === "undefined";
 function isTypedArraySameAsArrayBuffer(typedArray) {
   return typedArray.byteOffset === 0 && typedArray.byteLength === typedArray.buffer.byteLength;
 }
@@ -3027,6 +3015,309 @@ class BlobReader {
     return this.blob.slice(offset, offset + length, type);
   }
 }
+function inflate(data, buf) {
+  var u8 = Uint8Array;
+  if (data[0] == 3 && data[1] == 0)
+    return buf ? buf : new u8(0);
+  var bitsF = _bitsF, bitsE = _bitsE, decodeTiny = _decodeTiny, get17 = _get17;
+  var noBuf = buf == null;
+  if (noBuf)
+    buf = new u8(data.length >>> 2 << 3);
+  var BFINAL = 0, BTYPE = 0, HLIT = 0, HDIST = 0, HCLEN = 0, ML = 0, MD = 0;
+  var off = 0, pos = 0;
+  var lmap, dmap;
+  while (BFINAL == 0) {
+    BFINAL = bitsF(data, pos, 1);
+    BTYPE = bitsF(data, pos + 1, 2);
+    pos += 3;
+    if (BTYPE == 0) {
+      if ((pos & 7) != 0)
+        pos += 8 - (pos & 7);
+      var p8 = (pos >>> 3) + 4, len = data[p8 - 4] | data[p8 - 3] << 8;
+      if (noBuf)
+        buf = _check(buf, off + len);
+      buf.set(new u8(data.buffer, data.byteOffset + p8, len), off);
+      pos = p8 + len << 3;
+      off += len;
+      continue;
+    }
+    if (noBuf)
+      buf = _check(buf, off + (1 << 17));
+    if (BTYPE == 1) {
+      lmap = U.flmap;
+      dmap = U.fdmap;
+      ML = (1 << 9) - 1;
+      MD = (1 << 5) - 1;
+    }
+    if (BTYPE == 2) {
+      HLIT = bitsE(data, pos, 5) + 257;
+      HDIST = bitsE(data, pos + 5, 5) + 1;
+      HCLEN = bitsE(data, pos + 10, 4) + 4;
+      pos += 14;
+      for (var i = 0;i < 38; i += 2) {
+        U.itree[i] = 0;
+        U.itree[i + 1] = 0;
+      }
+      var tl = 1;
+      for (var i = 0;i < HCLEN; i++) {
+        var l = bitsE(data, pos + i * 3, 3);
+        U.itree[(U.ordr[i] << 1) + 1] = l;
+        if (l > tl)
+          tl = l;
+      }
+      pos += 3 * HCLEN;
+      makeCodes(U.itree, tl);
+      codes2map(U.itree, tl, U.imap);
+      lmap = U.lmap;
+      dmap = U.dmap;
+      pos = decodeTiny(U.imap, (1 << tl) - 1, HLIT + HDIST, data, pos, U.ttree);
+      var mx0 = _copyOut(U.ttree, 0, HLIT, U.ltree);
+      ML = (1 << mx0) - 1;
+      var mx1 = _copyOut(U.ttree, HLIT, HDIST, U.dtree);
+      MD = (1 << mx1) - 1;
+      makeCodes(U.ltree, mx0);
+      codes2map(U.ltree, mx0, lmap);
+      makeCodes(U.dtree, mx1);
+      codes2map(U.dtree, mx1, dmap);
+    }
+    while (true) {
+      var code = lmap[get17(data, pos) & ML];
+      pos += code & 15;
+      var lit = code >>> 4;
+      if (lit >>> 8 == 0) {
+        buf[off++] = lit;
+      } else if (lit == 256) {
+        break;
+      } else {
+        var end = off + lit - 254;
+        if (lit > 264) {
+          var ebs = U.ldef[lit - 257];
+          end = off + (ebs >>> 3) + bitsE(data, pos, ebs & 7);
+          pos += ebs & 7;
+        }
+        var dcode = dmap[get17(data, pos) & MD];
+        pos += dcode & 15;
+        var dlit = dcode >>> 4;
+        var dbs = U.ddef[dlit], dst = (dbs >>> 4) + bitsF(data, pos, dbs & 15);
+        pos += dbs & 15;
+        if (noBuf)
+          buf = _check(buf, off + (1 << 17));
+        while (off < end) {
+          buf[off] = buf[off++ - dst];
+          buf[off] = buf[off++ - dst];
+          buf[off] = buf[off++ - dst];
+          buf[off] = buf[off++ - dst];
+        }
+        off = end;
+      }
+    }
+  }
+  return buf.length == off ? buf : buf.slice(0, off);
+}
+function _check(buf, len) {
+  var bl = buf.length;
+  if (len <= bl)
+    return buf;
+  var nbuf = new Uint8Array(Math.max(bl << 1, len));
+  nbuf.set(buf, 0);
+  return nbuf;
+}
+function _decodeTiny(lmap, LL, len, data, pos, tree) {
+  var bitsE = _bitsE, get17 = _get17;
+  var i = 0;
+  while (i < len) {
+    var code = lmap[get17(data, pos) & LL];
+    pos += code & 15;
+    var lit = code >>> 4;
+    if (lit <= 15) {
+      tree[i] = lit;
+      i++;
+    } else {
+      var ll = 0, n = 0;
+      if (lit == 16) {
+        n = 3 + bitsE(data, pos, 2);
+        pos += 2;
+        ll = tree[i - 1];
+      } else if (lit == 17) {
+        n = 3 + bitsE(data, pos, 3);
+        pos += 3;
+      } else if (lit == 18) {
+        n = 11 + bitsE(data, pos, 7);
+        pos += 7;
+      }
+      var ni = i + n;
+      while (i < ni) {
+        tree[i] = ll;
+        i++;
+      }
+    }
+  }
+  return pos;
+}
+function _copyOut(src, off, len, tree) {
+  var mx = 0, i = 0, tl = tree.length >>> 1;
+  while (i < len) {
+    var v = src[i + off];
+    tree[i << 1] = 0;
+    tree[(i << 1) + 1] = v;
+    if (v > mx)
+      mx = v;
+    i++;
+  }
+  while (i < tl) {
+    tree[i << 1] = 0;
+    tree[(i << 1) + 1] = 0;
+    i++;
+  }
+  return mx;
+}
+function makeCodes(tree, MAX_BITS) {
+  var max_code = tree.length;
+  var code, bits, n, i, len;
+  var bl_count = U.bl_count;
+  for (var i = 0;i <= MAX_BITS; i++)
+    bl_count[i] = 0;
+  for (i = 1;i < max_code; i += 2)
+    bl_count[tree[i]]++;
+  var next_code = U.next_code;
+  code = 0;
+  bl_count[0] = 0;
+  for (bits = 1;bits <= MAX_BITS; bits++) {
+    code = code + bl_count[bits - 1] << 1;
+    next_code[bits] = code;
+  }
+  for (n = 0;n < max_code; n += 2) {
+    len = tree[n + 1];
+    if (len != 0) {
+      tree[n] = next_code[len];
+      next_code[len]++;
+    }
+  }
+}
+function codes2map(tree, MAX_BITS, map) {
+  var max_code = tree.length;
+  var r15 = U.rev15;
+  for (var i = 0;i < max_code; i += 2)
+    if (tree[i + 1] != 0) {
+      var lit = i >> 1;
+      var cl = tree[i + 1], val = lit << 4 | cl;
+      var rest = MAX_BITS - cl, i0 = tree[i] << rest, i1 = i0 + (1 << rest);
+      while (i0 != i1) {
+        var p0 = r15[i0] >>> 15 - MAX_BITS;
+        map[p0] = val;
+        i0++;
+      }
+    }
+}
+function revCodes(tree, MAX_BITS) {
+  var r15 = U.rev15, imb = 15 - MAX_BITS;
+  for (var i = 0;i < tree.length; i += 2) {
+    var i0 = tree[i] << MAX_BITS - tree[i + 1];
+    tree[i] = r15[i0] >>> imb;
+  }
+}
+function _bitsE(dt, pos, length) {
+  return (dt[pos >>> 3] | dt[(pos >>> 3) + 1] << 8) >>> (pos & 7) & (1 << length) - 1;
+}
+function _bitsF(dt, pos, length) {
+  return (dt[pos >>> 3] | dt[(pos >>> 3) + 1] << 8 | dt[(pos >>> 3) + 2] << 16) >>> (pos & 7) & (1 << length) - 1;
+}
+function _get17(dt, pos) {
+  return (dt[pos >>> 3] | dt[(pos >>> 3) + 1] << 8 | dt[(pos >>> 3) + 2] << 16) >>> (pos & 7);
+}
+var U = function() {
+  var u16 = Uint16Array, u32 = Uint32Array;
+  return {
+    next_code: new u16(16),
+    bl_count: new u16(16),
+    ordr: [16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15],
+    of0: [3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31, 35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258, 999, 999, 999],
+    exb: [0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0, 0, 0, 0],
+    ldef: new u16(32),
+    df0: [1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193, 257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145, 8193, 12289, 16385, 24577, 65535, 65535],
+    dxb: [0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13, 0, 0],
+    ddef: new u32(32),
+    flmap: new u16(512),
+    fltree: [],
+    fdmap: new u16(32),
+    fdtree: [],
+    lmap: new u16(32768),
+    ltree: [],
+    ttree: [],
+    dmap: new u16(32768),
+    dtree: [],
+    imap: new u16(512),
+    itree: [],
+    rev15: new u16(1 << 15),
+    lhst: new u32(286),
+    dhst: new u32(30),
+    ihst: new u32(19),
+    lits: new u32(15000),
+    strt: new u16(1 << 16),
+    prev: new u16(1 << 15)
+  };
+}();
+(function() {
+  var len = 1 << 15;
+  for (var i = 0;i < len; i++) {
+    var x = i;
+    x = (x & 2863311530) >>> 1 | (x & 1431655765) << 1;
+    x = (x & 3435973836) >>> 2 | (x & 858993459) << 2;
+    x = (x & 4042322160) >>> 4 | (x & 252645135) << 4;
+    x = (x & 4278255360) >>> 8 | (x & 16711935) << 8;
+    U.rev15[i] = (x >>> 16 | x << 16) >>> 17;
+  }
+  function pushV(tgt, n, sv) {
+    while (n-- != 0)
+      tgt.push(0, sv);
+  }
+  for (var i = 0;i < 32; i++) {
+    U.ldef[i] = U.of0[i] << 3 | U.exb[i];
+    U.ddef[i] = U.df0[i] << 4 | U.dxb[i];
+  }
+  pushV(U.fltree, 144, 8);
+  pushV(U.fltree, 255 - 143, 9);
+  pushV(U.fltree, 279 - 255, 7);
+  pushV(U.fltree, 287 - 279, 8);
+  makeCodes(U.fltree, 9);
+  codes2map(U.fltree, 9, U.flmap);
+  revCodes(U.fltree, 9);
+  pushV(U.fdtree, 32, 5);
+  makeCodes(U.fdtree, 5);
+  codes2map(U.fdtree, 5, U.fdmap);
+  revCodes(U.fdtree, 5);
+  pushV(U.itree, 19, 0);
+  pushV(U.ltree, 286, 0);
+  pushV(U.dtree, 30, 0);
+  pushV(U.ttree, 320, 0);
+})();
+var crc = {
+  table: function() {
+    var tab = new Uint32Array(256);
+    for (var n = 0;n < 256; n++) {
+      var c = n;
+      for (var k = 0;k < 8; k++) {
+        if (c & 1)
+          c = 3988292384 ^ c >>> 1;
+        else
+          c = c >>> 1;
+      }
+      tab[n] = c;
+    }
+    return tab;
+  }(),
+  update: function(c, buf, off, len) {
+    for (var i = 0;i < len; i++)
+      c = crc.table[(c ^ buf[off + i]) & 255] ^ c >>> 8;
+    return c;
+  },
+  crc: function(b, o, l) {
+    return crc.update(4294967295, b, o, l) ^ 4294967295;
+  }
+};
+function inflateRaw(file, buf) {
+  return inflate(file, buf);
+}
 var config = {
   numWorkers: 1,
   workerURL: "",
@@ -3055,8 +3346,8 @@ function startWorker(url) {
     const worker = new Worker(url);
     worker.onmessage = (e) => {
       if (e.data === "start") {
-        worker.onerror = null;
-        worker.onmessage = null;
+        worker.onerror = undefined;
+        worker.onmessage = undefined;
         resolve(worker);
       } else {
         reject(new Error(`unexpected message: ${e.data}`));
@@ -3065,12 +3356,14 @@ function startWorker(url) {
     worker.onerror = reject;
   });
 }
+function dynamicRequire(mod, request) {
+  return mod.require ? mod.require(request) : {};
+}
 var workerHelper = function() {
   if (isNode) {
+    const { Worker: Worker2 } = dynamicRequire(module_unzipit_module, "worker_threads");
     return {
       async createWorker(url) {
-        const moduleId = "node:worker_threads";
-        const { Worker: Worker2 } = await import(moduleId);
         return new Worker2(url);
       },
       addEventListener(worker, fn) {
@@ -3088,7 +3381,7 @@ var workerHelper = function() {
         try {
           const worker = await startWorker(url);
           return worker;
-        } catch (_e) {
+        } catch (e) {
           console.warn("could not load worker:", url);
         }
         let text;
@@ -3102,7 +3395,7 @@ var workerHelper = function() {
           const worker = await startWorker(url);
           config.workerURL = url;
           return worker;
-        } catch (_e) {
+        } catch (e) {
           console.warn("could not load worker via fetch:", url);
         }
         if (text !== undefined) {
@@ -3111,7 +3404,7 @@ var workerHelper = function() {
             const worker = await startWorker(url);
             config.workerURL = url;
             return worker;
-          } catch (_e) {
+          } catch (e) {
             console.warn("could not load worker via dataURI");
           }
         }
@@ -3139,41 +3432,16 @@ async function getAvailableWorker() {
       workers.push(worker);
       availableWorkers.push(worker);
       workerHelper.addEventListener(worker, handleResult);
-    } catch (_e) {
+    } catch (e) {
       canUseWorkers = false;
     }
   }
   return availableWorkers.pop();
 }
-async function decompressRaw(src) {
-  const ds = new DecompressionStream("deflate-raw");
-  const writer = ds.writable.getWriter();
-  writer.write(src).then(() => writer.close()).catch(() => {});
-  const chunks = [];
-  const reader = ds.readable.getReader();
-  for (;; ) {
-    const { done, value } = await reader.read();
-    if (done) {
-      break;
-    }
-    chunks.push(value);
-  }
-  const size = chunks.reduce((s, c) => s + c.byteLength, 0);
-  const result = new Uint8Array(size);
-  let offset = 0;
-  for (const chunk of chunks) {
-    result.set(chunk, offset);
-    offset += chunk.byteLength;
-  }
-  return result;
-}
-async function inflateRawLocal(src, type, resolve, reject) {
-  try {
-    const dst = await decompressRaw(src);
-    resolve(type ? new Blob([dst], { type }) : dst.buffer);
-  } catch (e) {
-    reject(e);
-  }
+function inflateRawLocal(src, uncompressedSize, type, resolve) {
+  const dst = new Uint8Array(uncompressedSize);
+  inflateRaw(src, dst);
+  resolve(type ? new Blob([dst], { type }) : dst.buffer);
 }
 async function processWaitingForWorkerQueue() {
   if (waitingForWorkerQueue.length === 0) {
@@ -3188,7 +3456,7 @@ async function processWaitingForWorkerQueue() {
           return;
         }
         const { id, src, uncompressedSize, type, resolve, reject } = waitingForWorkerQueue.shift();
-        currentlyProcessingIdToRequestMap.set(id, { id, src, uncompressedSize, type, resolve, reject });
+        currentlyProcessingIdToRequestMap.set(id, { id, resolve, reject });
         const transferables = [];
         worker.postMessage({
           type: "inflate",
@@ -3204,9 +3472,12 @@ async function processWaitingForWorkerQueue() {
     }
   }
   while (waitingForWorkerQueue.length) {
-    const { src, type, resolve, reject } = waitingForWorkerQueue.shift();
-    const data = isBlob(src) ? await readBlobAsUint8Array(src) : src;
-    inflateRawLocal(data, type, resolve, reject);
+    const { src, uncompressedSize, type, resolve } = waitingForWorkerQueue.shift();
+    let data = src;
+    if (isBlob(src)) {
+      data = await readBlobAsUint8Array(src);
+    }
+    inflateRawLocal(data, uncompressedSize, type, resolve);
   }
 }
 function inflateRawAsync(src, uncompressedSize, type) {
@@ -3271,7 +3542,7 @@ async function readAsBlobOrTypedArray(reader, offset, length, type) {
   }
   return await reader.read(offset, length);
 }
-var crc = {
+var crc$1 = {
   unsigned() {
     return 0;
   }
@@ -3286,7 +3557,7 @@ function getUint64LE(uint8View, offset) {
   return getUint32LE(uint8View, offset) + getUint32LE(uint8View, offset + 4) * 4294967296;
 }
 var utf8Decoder = new TextDecoder;
-function decodeBuffer(uint8View, _isUTF8) {
+function decodeBuffer(uint8View, isUTF8) {
   if (isSharedArrayBuffer(uint8View.buffer)) {
     uint8View = new Uint8Array(uint8View);
   }
@@ -3373,7 +3644,6 @@ async function readEntries(reader, centralDirectoryOffset, centralDirectorySize,
     }
     readEntryCursor += 46;
     const data = allEntriesBuffer.subarray(readEntryCursor, readEntryCursor + rawEntry.fileNameLength + rawEntry.extraFieldLength + rawEntry.fileCommentLength);
-    rawEntry.generalPurposeBitFlag & 2048;
     rawEntry.nameBytes = data.slice(0, rawEntry.fileNameLength);
     rawEntry.name = decodeBuffer(rawEntry.nameBytes);
     const fileCommentStart = rawEntry.fileNameLength + rawEntry.extraFieldLength;
@@ -3426,7 +3696,7 @@ async function readEntries(reader, centralDirectoryOffset, centralDirectorySize,
         index += 8;
       }
     }
-    const nameField = rawEntry.extraFields.find((e2) => e2.id === 28789 && e2.data.length >= 6 && e2.data[0] === 1 && getUint32LE(e2.data, 1), crc.unsigned());
+    const nameField = rawEntry.extraFields.find((e2) => e2.id === 28789 && e2.data.length >= 6 && e2.data[0] === 1 && getUint32LE(e2.data, 1), crc$1.unsigned(rawEntry.nameBytes));
     if (nameField) {
       rawEntry.fileName = decodeBuffer(nameField.data.slice(5));
     }
@@ -3490,7 +3760,7 @@ async function readEntryDataAsArrayBuffer(reader, rawEntry) {
     return isTypedArraySameAsArrayBuffer(dataView) ? dataView.buffer : dataView.slice().buffer;
   }
   const typedArrayOrBlob = await readAsBlobOrTypedArray(reader, fileDataStart, rawEntry.compressedSize);
-  const result = await inflateRawAsync(typedArrayOrBlob instanceof Uint8Array ? typedArrayOrBlob : typedArrayOrBlob, rawEntry.uncompressedSize);
+  const result = await inflateRawAsync(typedArrayOrBlob, rawEntry.uncompressedSize);
   return result;
 }
 async function readEntryDataAsBlob(reader, rawEntry, type) {
@@ -3500,10 +3770,10 @@ async function readEntryDataAsBlob(reader, rawEntry, type) {
     if (isBlob(typedArrayOrBlob2)) {
       return typedArrayOrBlob2;
     }
-    return new Blob([typedArrayOrBlob2], { type });
+    return new Blob([isSharedArrayBuffer(typedArrayOrBlob2.buffer) ? new Uint8Array(typedArrayOrBlob2) : typedArrayOrBlob2], { type });
   }
   const typedArrayOrBlob = await readAsBlobOrTypedArray(reader, fileDataStart, rawEntry.compressedSize);
-  const result = await inflateRawAsync(typedArrayOrBlob instanceof Uint8Array ? typedArrayOrBlob : typedArrayOrBlob, rawEntry.uncompressedSize, type);
+  const result = await inflateRawAsync(typedArrayOrBlob, rawEntry.uncompressedSize, type);
   return result;
 }
 async function unzipRaw(source) {
@@ -3540,14 +3810,14 @@ async function unzip(source) {
   };
 }
 
-// ../serial/src/vex-device.ts
-function downloadFileFromInternet(link) {
-  return new Promise((resolve, reject) => {
-    var oReq = new XMLHttpRequest;
+// ../serial/src/VexDevice.ts
+async function downloadFileFromInternet(link) {
+  return await new Promise((resolve, reject) => {
+    const oReq = new XMLHttpRequest;
     oReq.open("GET", link, true);
     oReq.responseType = "arraybuffer";
     oReq.onload = function(_oEvent) {
-      var arrayBuffer = oReq.response;
+      const arrayBuffer = oReq.response;
       resolve(arrayBuffer);
     };
     oReq.onerror = function(oEvent) {
@@ -3556,11 +3826,37 @@ function downloadFileFromInternet(link) {
     oReq.send(null);
   });
 }
-function sleepUntil(f, timeout, interval = 20) {
-  return new Promise((resolve) => {
+async function sleepUntilAsync(f, timeout, interval = 20) {
+  return await new Promise((resolve) => {
+    let lastTime = new Date().getTime();
+    let stopped = false;
+    const stopper = setTimeout(() => {
+      stopped = true;
+      resolve(false);
+    }, timeout);
+    const checker = (val) => {
+      if (stopped)
+        return;
+      if (val) {
+        clearTimeout(stopper);
+        resolve(true);
+      } else if (new Date().getTime() - lastTime > interval) {
+        lastTime = new Date().getTime();
+        f().then(checker);
+      } else
+        setTimeout(() => {
+          lastTime = new Date().getTime();
+          f().then(checker);
+        }, new Date().getTime() - lastTime);
+    };
+    f().then(checker);
+  });
+}
+async function sleepUntil(f, timeout, interval = 20) {
+  return await new Promise((resolve) => {
     const timeWas = new Date().getTime();
-    const wait = setInterval(async function() {
-      if (await f()) {
+    const wait = setInterval(function() {
+      if (f()) {
         clearInterval(wait);
         resolve(true);
       } else if (new Date().getTime() - timeWas > timeout) {
@@ -3570,28 +3866,15 @@ function sleepUntil(f, timeout, interval = 20) {
     }, interval);
   });
 }
-function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-function shallowEqual(object1, object2) {
-  const keys1 = Object.keys(object1);
-  const keys2 = Object.keys(object2);
-  if (keys1.length !== keys2.length) {
-    return false;
-  }
-  for (let key of keys1) {
-    if (object1[key] !== object2[key]) {
-      return false;
-    }
-  }
-  return true;
+async function sleep(ms) {
+  return await new Promise((resolve) => setTimeout(resolve, ms));
 }
 
 class VexSerialDevice extends VexEventTarget {
   connection;
   defaultSerial;
   get isConnected() {
-    return this.connection ? this.connection.isConnected : false;
+    return this.connection != null ? this.connection.isConnected : false;
   }
   get deviceType() {
     return this.isConnected ? this.connection?.port?.getInfo().usbProductId : undefined;
@@ -3602,40 +3885,6 @@ class VexSerialDevice extends VexEventTarget {
   }
 }
 
-class V5SerialDeviceProxyHandler {
-  device;
-  parent;
-  rootkey;
-  constructor(device, parent, rootkey) {
-    this.device = device;
-    this.parent = parent;
-    this.rootkey = rootkey;
-  }
-  get(target, key) {
-    if (typeof target[key] === "object" && target[key] !== null && (typeof key !== "string" ? true : !key.startsWith("_"))) {
-      return new Proxy(target[key], new V5SerialDeviceProxyHandler(this.device, this, key));
-    } else {
-      return target[key];
-    }
-  }
-  set(target, key, value) {
-    let oldValue = target[key];
-    if (oldValue === value) {
-      return true;
-    } else if (typeof oldValue === "object" && typeof value === "object" && oldValue !== null && value !== null) {
-      if (shallowEqual(oldValue, value))
-        return true;
-    }
-    target[key] = value;
-    this.parent?.childSet(this.rootkey, key, value);
-    return true;
-  }
-  childSet(rootkey, subkey, value) {
-    if (this.parent)
-      this.parent.childSet(this.rootkey, rootkey + "." + subkey, value);
-  }
-}
-
 class V5SerialDeviceState {
   _instance;
   _isFileTransferring = false;
@@ -3704,11 +3953,11 @@ class V5Brain {
     (async () => {
       if (this.state.brain.activeProgram === value)
         return;
-      let conn = this.state._instance.connection;
-      if (!conn)
+      const conn = this.state._instance.connection;
+      if (conn == null)
         return;
-      let fn = value === 0 ? await conn.stopProgram() : await conn.loadProgram(value);
-      if (fn)
+      const fn = value === 0 ? await conn.stopProgram() : await conn.loadProgram(value);
+      if (fn != null)
         this.state.brain.activeProgram = value;
     })();
   }
@@ -3737,26 +3986,26 @@ class V5Brain {
     return this.state.brain.uniqueId;
   }
   async getValue(key) {
-    let result = await this.state._instance.connection?.writeDataAsync(new ReadKeyValueH2DPacket(key));
+    const result = await this.state._instance.connection?.writeDataAsync(new ReadKeyValueH2DPacket(key));
     return result instanceof ReadKeyValueReplyD2HPacket ? result.value : undefined;
   }
   async setValue(key, value) {
-    let result = await this.state._instance.connection?.writeDataAsync(new WriteKeyValueH2DPacket(key, value));
-    return result instanceof WriteKeyValueReplyD2HPacket ? true : false;
+    const result = await this.state._instance.connection?.writeDataAsync(new WriteKeyValueH2DPacket(key, value));
+    return result instanceof WriteKeyValueReplyD2HPacket;
   }
   async listFiles(vendor = 1 /* USER */) {
-    let conn = this.state._instance.connection;
-    if (!conn)
+    const conn = this.state._instance.connection;
+    if (conn == null || !conn.isConnected)
       return;
-    let result = await conn.writeDataAsync(new GetDirectoryFileCountH2DPacket(vendor));
+    const result = await conn.writeDataAsync(new GetDirectoryFileCountH2DPacket(vendor));
     if (!(result instanceof GetDirectoryFileCountReplyD2HPacket))
       return;
-    let files = [];
+    const files = [];
     for (let i = 0;i < result.count; i++) {
-      let result2 = await conn.writeDataAsync(new GetDirectoryEntryH2DPacket(i));
+      const result2 = await conn.writeDataAsync(new GetDirectoryEntryH2DPacket(i));
       if (!(result2 instanceof GetDirectoryEntryReplyD2HPacket))
         return;
-      if (result2.file) {
+      if (result2.file != null) {
         files.push({
           filename: result2.file.filename,
           vendor,
@@ -3772,25 +4021,25 @@ class V5Brain {
     return files;
   }
   async listProgram() {
-    let conn = this.state._instance.connection;
-    if (!conn?.isConnected)
+    const conn = this.state._instance.connection;
+    if (conn == null || !conn.isConnected)
       return;
-    let files = await this.listFiles(1 /* USER */);
+    const files = await this.listFiles(1 /* USER */);
     if (files === undefined)
       return;
-    let programList = [];
-    let iniFiles = files.filter((file) => file && file.filename.search(/.ini$/) > 0);
+    const programList = [];
+    const iniFiles = files.filter((file) => file?.filename.search(/.ini$/) > 0);
     for (let i = 0;i < iniFiles.length; i++) {
-      let ini = iniFiles[i];
-      if (!ini.size)
+      const ini = iniFiles[i];
+      if (ini.size === 0)
         continue;
-      let programName = (/(.+?)(\.[^.]*$|$)/.exec(ini.filename) || "")[1];
-      let bin = files.filter((e) => e && e.filename === programName + ".bin")[0];
-      if (!bin || !bin.timestamp || !bin.size)
+      const programName = /(.+?)(\.[^.]*$|$)/.exec(ini.filename)?.[1] ?? "";
+      const bin = files.filter((e) => e != null && e.filename === programName + ".bin")[0];
+      if (bin == null || bin.timestamp === 0 || bin.size === 0)
         continue;
-      let n = new Date;
+      const n = new Date;
       n.setTime(1000 * bin.timestamp);
-      let program = {
+      const program = {
         name: programName,
         binfile: bin.filename,
         size: ini.size + bin.size,
@@ -3798,7 +4047,7 @@ class V5Brain {
         time: n,
         requestedSlot: -1
       };
-      let result2 = await conn.writeDataAsync(new GetProgramSlotInfoH2DPacket(1 /* USER */, program.binfile));
+      const result2 = await conn?.writeDataAsync(new GetProgramSlotInfoH2DPacket(1 /* USER */, program.binfile));
       if (result2 instanceof GetProgramSlotInfoReplyD2HPacket) {
         program.slot = result2.slot;
         program.requestedSlot = result2.requestedSlot;
@@ -3808,8 +4057,8 @@ class V5Brain {
     return programList;
   }
   async readFile(request, downloadTarget = 1 /* FILE_TARGET_QSPI */, progressCallback) {
-    let conn = this.state._instance.connection;
-    if (!conn?.isConnected)
+    const conn = this.state._instance.connection;
+    if (conn == null || !conn.isConnected)
       return;
     this.state._isFileTransferring = true;
     let handle;
@@ -3819,16 +4068,15 @@ class V5Brain {
       handle = request;
     }
     try {
-      return conn.downloadFileToHost(handle, downloadTarget, progressCallback);
+      return await conn.downloadFileToHost(handle, downloadTarget, progressCallback);
     } catch (e) {
-      throw e;
-    } finally {
       this.state._isFileTransferring = false;
+      throw e;
     }
   }
   async removeFile(request) {
-    let conn = this.state._instance.connection;
-    if (!conn?.isConnected)
+    const conn = this.state._instance.connection;
+    if (conn == null || !conn.isConnected)
       return;
     let vendor, filename;
     if (typeof request === "string") {
@@ -3838,8 +4086,8 @@ class V5Brain {
       vendor = request.vendor;
       filename = request.filename;
     }
-    let result = await conn.writeDataAsync(new EraseFileH2DPacket(vendor, filename));
-    let result2 = await conn.writeDataAsync(new ExitFileTransferH2DPacket(3 /* EXIT_HALT */));
+    const result = await conn.writeDataAsync(new EraseFileH2DPacket(vendor, filename));
+    const result2 = await conn.writeDataAsync(new ExitFileTransferH2DPacket(3 /* EXIT_HALT */));
     if (!(result instanceof EraseFileReplyD2HPacket))
       return false;
     if (!(result2 instanceof ExitFileTransferReplyD2HPacket))
@@ -3847,16 +4095,16 @@ class V5Brain {
     return true;
   }
   async removeAllFiles() {
-    let conn = this.state._instance.connection;
-    if (!conn?.isConnected)
+    const conn = this.state._instance.connection;
+    if (conn == null || !conn.isConnected)
       return;
-    let result = await conn.writeDataAsync(new FileClearUpH2DPacket(1 /* USER */), 30000);
-    return result instanceof FileClearUpReplyD2HPacket ? true : false;
+    const result = await conn.writeDataAsync(new FileClearUpH2DPacket(1 /* USER */), 30000);
+    return result instanceof FileClearUpReplyD2HPacket;
   }
   async uploadFirmware(publicUrl = "https://content.vexrobotics.com/vexos/public/V5/", usingVersion, progressCallback) {
-    let device = this.state._instance;
-    let conn = device.connection;
-    if (!conn?.isConnected)
+    const device = this.state._instance;
+    const conn = device.connection;
+    if (conn == null || !conn.isConnected)
       return;
     const pcb = progressCallback ?? (() => {});
     let vexos, bootBin, assertBin;
@@ -3864,7 +4112,7 @@ class V5Brain {
       if (usingVersion === undefined) {
         pcb("FETCH CATALOG", 0, 1);
         const catalog = await downloadFileFromInternet(publicUrl + "catalog.txt");
-        let latestVersion = new TextDecoder().decode(catalog);
+        const latestVersion = new TextDecoder().decode(catalog);
         usingVersion = latestVersion;
         pcb("FETCH CATALOG", 1, 1);
         console.log("fetched catalog.txt", latestVersion);
@@ -3873,7 +4121,7 @@ class V5Brain {
       vexos = await downloadFileFromInternet(publicUrl + usingVersion + ".vexos");
       pcb("FETCH VEXOS", 1, 1);
       pcb("UNZIP VEXOS", 0, 1);
-      let { entries } = await unzip(vexos);
+      const { entries } = await unzip(vexos);
       bootBin = await entries[usingVersion + "/BOOT.bin"].arrayBuffer();
       assertBin = await entries[usingVersion + "/assets.bin"].arrayBuffer();
       pcb("UNZIP VEXOS", 1, 1);
@@ -3883,10 +4131,10 @@ class V5Brain {
     try {
       this.state._isFileTransferring = true;
       pcb("FACTORY ENB BOOT", 0, 0);
-      let result = await conn.writeDataAsync(new FactoryEnableH2DPacket);
+      const result = await conn.writeDataAsync(new FactoryEnableH2DPacket);
       if (!(result instanceof FactoryEnableReplyD2HPacket))
         return false;
-      let bootWriteRequest = {
+      const bootWriteRequest = {
         filename: "null.bin",
         vendor: 1 /* USER */,
         loadAddress: USER_FLASH_USR_CODE_START,
@@ -3896,11 +4144,13 @@ class V5Brain {
         autoRun: true,
         linkedFile: undefined
       };
-      let result2 = await conn.uploadFileToDevice(bootWriteRequest, (c, t) => pcb("UPLOAD BOOT", c, t));
+      const result2 = await conn.uploadFileToDevice(bootWriteRequest, (c, t) => {
+        pcb("UPLOAD BOOT", c, t);
+      });
       if (!result2)
         return false;
       while (true) {
-        let result3 = await conn.writeDataAsync(new FactoryStatusH2DPacket, 1e4);
+        const result3 = await conn.writeDataAsync(new FactoryStatusH2DPacket, 1e4);
         if (result3 instanceof FactoryStatusReplyD2HPacket) {
           switch (result3.status) {
             case 2:
@@ -3924,10 +4174,10 @@ class V5Brain {
         await sleep(500);
       }
       pcb("FACTORY ENB ASSERT", 0, 0);
-      let result5 = await conn.writeDataAsync(new FactoryEnableH2DPacket);
+      const result5 = await conn.writeDataAsync(new FactoryEnableH2DPacket);
       if (!(result5 instanceof FactoryEnableReplyD2HPacket))
         return false;
-      let assertWriteRequest = {
+      const assertWriteRequest = {
         filename: "null.bin",
         vendor: 1 /* USER */,
         loadAddress: USER_FLASH_USR_CODE_START,
@@ -3937,11 +4187,13 @@ class V5Brain {
         autoRun: true,
         linkedFile: undefined
       };
-      let result6 = await conn.uploadFileToDevice(assertWriteRequest, (c, t) => pcb("UPLOAD ASSERT", c, t));
+      const result6 = await conn.uploadFileToDevice(assertWriteRequest, (c, t) => {
+        pcb("UPLOAD ASSERT", c, t);
+      });
       if (!result6)
         return false;
       while (true) {
-        let result7 = await conn.writeDataAsync(new FactoryStatusH2DPacket, 1e4);
+        const result7 = await conn.writeDataAsync(new FactoryStatusH2DPacket, 1e4);
         if (result7 instanceof FactoryStatusReplyD2HPacket) {
           switch (result7.status) {
             case 2:
@@ -3965,64 +4217,90 @@ class V5Brain {
         await sleep(500);
       }
     } catch (e) {
-      throw e;
-    } finally {
       this.state._isFileTransferring = false;
+      throw e;
     }
     return true;
   }
   async uploadProgram(iniConfig, binFileBuf, coldFileBuf, progressCallback) {
-    let device = this.state._instance;
-    let conn = device.connection;
-    if (!conn?.isConnected)
+    const device = this.state._instance;
+    const conn = device.connection;
+    if (conn == null || !conn.isConnected)
       return;
     this.state._isFileTransferring = true;
     try {
       if (device.isV5Controller) {
         await sleep(250);
-        if (!device.refresh())
+        if (!await device.refresh())
           return;
         console.log("Transferring to download channel");
-        let p1 = await device.radio.changeChannel(1 /* DOWNLOAD */);
+        const p1 = await device.radio.changeChannel(1 /* DOWNLOAD */);
         if (!p1)
           return false;
         await sleep(250);
-        await sleepUntil(async () => await conn?.getSystemStatus(150), 1e4, 200);
+        await sleepUntilAsync(async () => await conn?.getSystemStatus(150) != null, 1e4, 200);
         console.log("Transferred to download channel");
       }
-      let p2 = await conn.uploadProgramToDevice(iniConfig, binFileBuf, coldFileBuf, progressCallback);
-      if (!p2)
+      const p2 = await conn.uploadProgramToDevice(iniConfig, binFileBuf, coldFileBuf, progressCallback);
+      if (!(p2 ?? false))
         return false;
       if (device.isV5Controller) {
         if (!device.brain.isAvailable)
           return false;
         console.log("Transferring back to pit channel");
-        let p3 = await device.radio.changeChannel(0 /* PIT */);
+        const p3 = await device.radio.changeChannel(0 /* PIT */);
         if (!p3)
           return false;
         await sleep(250);
-        await sleepUntil(async () => await conn?.getSystemStatus(150), 1e4, 200);
+        await sleepUntilAsync(async () => await conn?.getSystemStatus(150) != null, 1e4, 200);
         console.log("All done");
       }
       return true;
     } catch (e) {
-      throw e;
-    } finally {
       this.state._isFileTransferring = false;
+      throw e;
     }
   }
   async writeFile(request, progressCallback) {
     this.state._isFileTransferring = true;
-    let conn = this.state._instance.connection;
-    if (!conn?.isConnected)
+    const conn = this.state._instance.connection;
+    if (conn == null || !conn.isConnected)
       return;
     try {
-      return conn.uploadFileToDevice(request, progressCallback);
+      return await conn.uploadFileToDevice(request, progressCallback);
     } catch (e) {
-      throw e;
-    } finally {
       this.state._isFileTransferring = false;
+      throw e;
+    }
+  }
+  async captureScreen(progressCallback) {
+    const conn = this.state._instance.connection;
+    if (conn == null || !conn.isConnected)
+      return;
+    await new Promise((resolve) => {
+      conn.writeData(new ScreenCaptureH2DPacket(0), resolve);
+    });
+    const height = 272;
+    const width = 480;
+    const channels = 3;
+    const messageWidth = 512;
+    const messageChannels = 4;
+    let buf = await conn?.downloadFileToHost({
+      filename: "screen",
+      vendor: 15 /* SYS */,
+      loadAddress: 0,
+      size: messageWidth * height * messageChannels
+    }, 2 /* FILE_TARGET_CBUF */, progressCallback);
+    if (buf == null)
+      return;
+    buf = buf.filter((_byte, i) => i % (messageWidth * messageChannels) < width * messageChannels).filter((_byte, i) => (i + 1) % messageChannels !== 0);
+    for (let i = 0;i < buf.length; i += channels) {
+      const px = buf.slice(i, i + channels).reverse();
+      for (let j = 0;j < px.length; j++) {
+        buf[i + j] = px[j];
+      }
     }
+    return buf;
   }
 }
 
@@ -4096,17 +4374,20 @@ class V5SmartDevice {
     this.state = state;
     this.deviceIndex = index;
   }
+  getDeviceInfo() {
+    return this.state.devices[this.deviceIndex];
+  }
   get isAvailable() {
-    return this.state.devices[this.deviceIndex] !== undefined;
+    return this.getDeviceInfo() !== undefined;
   }
   get port() {
     return this.deviceIndex;
   }
   get type() {
-    return this.isAvailable ? this.state.devices[this.deviceIndex].type : 0 /* EMPTY */;
+    return this.getDeviceInfo()?.type ?? 0 /* EMPTY */;
   }
   get version() {
-    return this.isAvailable ? this.state.devices[this.deviceIndex].version : 0;
+    return this.getDeviceInfo()?.version ?? 0;
   }
 }
 
@@ -4134,8 +4415,8 @@ class V5Radio {
     return this.state.radio.latency;
   }
   async changeChannel(channel) {
-    let result = await this.state._instance.connection?.writeDataAsync(new FileControlH2DPacket(1, channel));
-    return result instanceof FileControlReplyD2HPacket ? true : false;
+    const result = await this.state._instance.connection?.writeDataAsync(new FileControlH2DPacket(1, channel));
+    return result instanceof FileControlReplyD2HPacket;
   }
 }
 
@@ -4143,36 +4424,23 @@ class V5SerialDevice extends VexSerialDevice {
   autoReconnect = true;
   autoRefresh = true;
   pauseRefreshOnFileTransfer = true;
-  _isDisconnecting = false;
   _isReconnecting = false;
-  _refreshInterval;
-  proxy = new V5SerialDeviceProxyHandler(this);
-  state = new Proxy(new V5SerialDeviceState(this), this.proxy);
+  state = new V5SerialDeviceState(this);
   constructor(defaultSerial) {
     super(defaultSerial);
-    this.startAutoRefresh();
-  }
-  startAutoRefresh() {
-    if (this._refreshInterval)
-      return;
-    this._refreshInterval = setInterval(() => {
-      if (this.autoRefresh) {
+    let isLastRefreshComplete = true;
+    setInterval(() => {
+      if (this.autoRefresh && isLastRefreshComplete) {
         if (!this.isConnected) {
           this.state.brain.isAvailable = false;
           return;
         }
         if (this.pauseRefreshOnFileTransfer && !this.state._isFileTransferring) {
-          this.refresh();
+          isLastRefreshComplete = false;
+          this.refresh().finally(() => isLastRefreshComplete = true);
         }
       }
     }, 200);
-    this._refreshInterval.unref?.();
-  }
-  stopAutoRefresh() {
-    if (!this._refreshInterval)
-      return;
-    clearInterval(this._refreshInterval);
-    this._refreshInterval = undefined;
   }
   get isV5Controller() {
     return this.deviceType === 1283 /* V5_CONTROLLER */;
@@ -4184,9 +4452,9 @@ class V5SerialDevice extends VexSerialDevice {
     return [new V5Controller(this.state, 0), new V5Controller(this.state, 1)];
   }
   get devices() {
-    let rtn = [];
+    const rtn = [];
     for (let i = 1;i <= this.state.devices.length; i++) {
-      if (this.state.devices[i])
+      if (this.state.devices[i] != null)
         rtn.push(new V5SmartDevice(this.state, i));
     }
     return rtn;
@@ -4199,7 +4467,7 @@ class V5SerialDevice extends VexSerialDevice {
   }
   set matchMode(value) {
     (async () => {
-      if (await this.connection?.setMatchMode(value))
+      if (await this.connection?.setMatchMode(value) != null)
         this.state.matchMode = value;
     })();
   }
@@ -4207,24 +4475,23 @@ class V5SerialDevice extends VexSerialDevice {
     return new V5Radio(this.state);
   }
   async mockTouch(x, y, press) {
-    return await this.connection?.mockTouch(x, y, press) ? true : false;
+    return !(await this.connection?.mockTouch(x, y, press) == null);
   }
   async connect(conn) {
     if (this.isConnected)
       return true;
-    this.startAutoRefresh();
-    if (conn?.isConnected) {
+    if (conn != null && !conn.isConnected) {
       if (await conn.query1() === null)
         return false;
       this.connection = conn;
     } else {
       let tryIdx = 0;
       while (true) {
-        let c = new V5SerialConnection(this.defaultSerial);
-        let result = await c.open(tryIdx++, true);
+        const c = new V5SerialConnection(this.defaultSerial);
+        const result = await c.open(tryIdx++, true);
         if (result === undefined)
           return false;
-        if (result === false) {
+        if (!result) {
           await c.close();
           continue;
         }
@@ -4242,44 +4509,38 @@ class V5SerialDevice extends VexSerialDevice {
     return true;
   }
   async disconnect() {
-    this._isDisconnecting = true;
-    this.stopAutoRefresh();
-    try {
-      await this.connection?.close();
-      this.connection = undefined;
-    } finally {
-      this._isDisconnecting = false;
-    }
+    await this.connection?.close();
+    this.connection = undefined;
   }
   async reconnect(timeout = 0) {
     if (this.isConnected)
       return true;
     if (timeout < 0)
       return false;
-    let endTime = new Date().getTime() + timeout;
+    const endTime = new Date().getTime() + timeout;
     if (this._isReconnecting) {
-      let successB4Timeout;
+      let successBeforeTimeout;
       do {
-        successB4Timeout = await sleepUntil(() => !this._isReconnecting, timeout || 1000);
-      } while (timeout === 0 && !successB4Timeout);
+        successBeforeTimeout = await sleepUntil(() => !this._isReconnecting, timeout === 0 ? 1000 : timeout);
+      } while (timeout === 0 && !successBeforeTimeout);
       if (this.isConnected)
         return true;
-      if (!successB4Timeout)
+      if (!successBeforeTimeout)
         return false;
     }
     this._isReconnecting = true;
-    while (timeout === 0 || new Date().getTime() > endTime) {
+    while (timeout === 0 || new Date().getTime() < endTime) {
       let tryIdx = 0;
       while (true) {
-        let c = new V5SerialConnection(this.defaultSerial);
-        let result = await c.open(tryIdx++, false);
+        const c = new V5SerialConnection(this.defaultSerial);
+        const result = await c.open(tryIdx++, false);
         if (result === undefined)
           break;
-        if (result === false) {
+        if (!result) {
           await c.close();
           continue;
         }
-        let result2 = await c.getSystemStatus(200);
+        const result2 = await c.getSystemStatus(200);
         if (result2 === null) {
           await c.close();
           continue;
@@ -4293,9 +4554,9 @@ class V5SerialDevice extends VexSerialDevice {
       }
       if (this.isConnected)
         break;
-      let getPortCount = async () => (await this.defaultSerial.getPorts()).length;
-      let portsCount = await getPortCount();
-      await sleepUntil(async () => await getPortCount() !== portsCount, 1000);
+      const getPortCount = async () => (await this.defaultSerial.getPorts()).length;
+      const portsCount = await getPortCount();
+      await sleepUntilAsync(async () => await getPortCount() !== portsCount, 1000);
     }
     this._isReconnecting = false;
     if (!this.isConnected)
@@ -4304,36 +4565,37 @@ class V5SerialDevice extends VexSerialDevice {
     return true;
   }
   async doAfterConnect() {
-    if (!this.connection)
+    if (this.connection == null)
       return;
+    console.log("doAfterConnect");
     this.connection.on("disconnected", (_data) => {
-      if (this.autoReconnect && !this._isDisconnecting)
+      if (this.autoReconnect)
         this.reconnect();
     });
     await this.refresh();
   }
   async refresh() {
-    let ssPacket = await this.connection?.getSystemStatus();
-    if (!ssPacket) {
+    const ssPacket = await this.connection?.getSystemStatus();
+    if (ssPacket == null) {
       this.state.brain.isAvailable = false;
       return false;
     }
     this.state.brain.cpu0Version = ssPacket.cpu0Version;
     this.state.brain.cpu1Version = ssPacket.cpu1Version;
     this.state.brain.systemVersion = ssPacket.systemVersion;
-    let flags2 = ssPacket.sysflags[2];
+    const flags2 = ssPacket.sysflags[2];
     this.state.controllers[0].isCharging = (flags2 & 128) !== 0;
-    this.state.matchMode = flags2 & 32 ? "disabled" : flags2 & 64 ? "autonomous" : "driver";
+    this.state.matchMode = (flags2 & 32) !== 0 ? "disabled" : (flags2 & 64) !== 0 ? "autonomous" : "driver";
     this.state.isFieldControllerConnected = (flags2 & 16) !== 0;
-    let flags4 = ssPacket.sysflags[4];
+    const flags4 = ssPacket.sysflags[4];
     this.state.brain.settings.usingLanguage = (flags4 & 240) >> 4;
     this.state.brain.settings.isWhiteTheme = (flags4 & 4) !== 0;
     this.state.brain.settings.isScreenReversed = (flags4 & 1) === 0;
     this.state.brain.uniqueId = ssPacket.uniqueId;
-    let sfPacket = await this.connection?.getSystemFlags();
-    if (!sfPacket)
+    const sfPacket = await this.connection?.getSystemFlags();
+    if (sfPacket == null)
       return false;
-    let flags5 = sfPacket.flags;
+    const flags5 = sfPacket.flags;
     this.state.radio.isRadioData = (flags5 & Math.pow(2, 32 - 12)) !== 0;
     this.state.brain.button.isDoublePressed = (flags5 & Math.pow(2, 32 - 14)) !== 0;
     this.state.brain.battery.isCharging = (flags5 & Math.pow(2, 32 - 15)) !== 0;
@@ -4342,29 +4604,31 @@ class V5SerialDevice extends VexSerialDevice {
     this.state.controllers[1].isAvailable = (flags5 & Math.pow(2, 32 - 19)) !== 0;
     this.state.radio.isConnected = (flags5 & Math.pow(2, 32 - 22)) !== 0;
     this.state.radio.isAvailable = (flags5 & Math.pow(2, 32 - 23)) !== 0;
-    this.state.brain.battery.batteryPercent = sfPacket.battery || 0;
+    this.state.brain.battery.batteryPercent = sfPacket.battery ?? 0;
     this.state.controllers[0].isAvailable = this.state.radio.isConnected || this.state.controllers[0].isCharging;
-    this.state.controllers[0].battery = sfPacket.controllerBatteryPercent || 0;
-    this.state.controllers[1].battery = sfPacket.partnerControllerBatteryPercent || 0;
+    this.state.controllers[0].battery = sfPacket.controllerBatteryPercent ?? 0;
+    this.state.controllers[1].battery = sfPacket.partnerControllerBatteryPercent ?? 0;
     this.state.brain.activeProgram = sfPacket.currentProgram;
     this.state.brain.isAvailable = !this.isV5Controller || this.state.radio.isConnected;
-    let rdPacket = await this.connection?.getRadioStatus();
-    if (!rdPacket)
+    const rdPacket = await this.connection?.getRadioStatus();
+    if (rdPacket == null)
       return false;
     this.state.radio.channel = rdPacket.channel;
     this.state.radio.latency = rdPacket.timeslot;
     this.state.radio.signalQuality = rdPacket.quality;
     this.state.radio.signalStrength = rdPacket.strength;
-    let dsPacket = await this.connection?.getDeviceStatus();
-    if (!dsPacket)
+    const dsPacket = await this.connection?.getDeviceStatus();
+    if (dsPacket == null)
       return false;
     let missingPorts = this.state.devices.map((d) => d?.port).filter((p) => p !== undefined);
     for (let i = 0;i < dsPacket.devices.length; i++) {
-      let device = dsPacket.devices[i];
+      const device = dsPacket.devices[i];
       this.state.devices[device.port] = device;
       missingPorts = missingPorts.filter((p) => p !== device.port);
     }
-    missingPorts.forEach((port) => delete this.state.devices[port]);
+    missingPorts.forEach((port) => {
+      this.state.devices[port] = undefined;
+    });
     return true;
   }
 }