@danidoble/webserial 4.3.3 → 4.3.5

package/dist/{webserial-core-ByrJ7tlu.js → webserial-core-BjytHor1.js}

@@ -1,32 +1,32 @@
-var j = Object.defineProperty, B = (i) => {
-  throw TypeError(i);
-}, F = (i, e, t) => e in i ? j(i, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : i[e] = t, g = (i, e, t) => F(i, typeof e != "symbol" ? e + "" : e, t), W = (i, e, t) => e.has(i) || B("Cannot " + t), Q = (i, e, t) => e.has(i) ? B("Cannot add the same private member more than once") : e instanceof WeakSet ? e.add(i) : e.set(i, t), l = (i, e, t) => (W(i, e, "access private method"), t);
-class x extends CustomEvent {
+var V = Object.defineProperty, R = (n) => {
+  throw TypeError(n);
+}, z = (n, e, t) => e in n ? V(n, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : n[e] = t, y = (n, e, t) => z(n, typeof e != "symbol" ? e + "" : e, t), T = (n, e, t) => e.has(n) || R("Cannot " + t), b = (n, e, t) => (T(n, e, "read from private field"), e.get(n)), S = (n, e, t) => e.has(n) ? R("Cannot add the same private member more than once") : e instanceof WeakSet ? e.add(n) : e.set(n, t), J = (n, e, t, i) => (T(n, e, "write to private field"), e.set(n, t), t), l = (n, e, t) => (T(n, e, "access private method"), t);
+class A extends CustomEvent {
   constructor(e, t) {
     super(e, t);
   }
 }
-class P extends EventTarget {
+class I extends EventTarget {
   constructor() {
-    super(...arguments), g(this, "__listeners__", {
+    super(...arguments), y(this, "__listeners__", {
       debug: !1
-    }), g(this, "__debug__", !1), g(this, "__listenersCallbacks__", []);
+    }), y(this, "__debug__", !1), y(this, "__listenersCallbacks__", []);
   }
   dispatch(e, t = null) {
-    const n = new x(e, { detail: t });
-    this.dispatchEvent(n), this.__debug__ && this.dispatchEvent(new x("debug", { detail: { type: e, data: t } }));
+    const i = new A(e, { detail: t });
+    this.dispatchEvent(i), this.__debug__ && this.dispatchEvent(new A("debug", { detail: { type: e, data: t } }));
   }
-  dispatchAsync(e, t = null, n = 100) {
+  dispatchAsync(e, t = null, i = 100) {
     const s = this;
     setTimeout(() => {
       s.dispatch(e, t);
-    }, n);
+    }, i);
   }
   on(e, t) {
     typeof this.__listeners__[e] < "u" && !this.__listeners__[e] && (this.__listeners__[e] = !0), this.__listenersCallbacks__.push({ key: e, callback: t }), this.addEventListener(e, t);
   }
   off(e, t) {
-    this.__listenersCallbacks__ = this.__listenersCallbacks__.filter((n) => !(n.key === e && n.callback === t)), this.removeEventListener(e, t);
+    this.__listenersCallbacks__ = this.__listenersCallbacks__.filter((i) => !(i.key === e && i.callback === t)), this.removeEventListener(e, t);
   }
   serialRegisterAvailableListener(e) {
     this.__listeners__[e] || (this.__listeners__[e] = !1);
@@ -39,13 +39,12 @@ class P extends EventTarget {
   }
   removeAllListeners() {
     for (const e of this.__listenersCallbacks__)
-      this.removeEventListener(e.key, e.callback);
-    this.__listenersCallbacks__ = [], this.__listeners__ = {
-      debug: !1
-    };
+      ["internal:queue"].includes(e.key) || (this.__listenersCallbacks__ = this.__listenersCallbacks__.filter((t) => !(t.key === e.key && t.callback === e.callback)), this.removeEventListener(e.key, e.callback));
+    for (const e of Object.keys(this.__listeners__))
+      this.__listeners__[e] = !1;
   }
 }
-const w = class a extends P {
+const C = class a extends I {
   constructor() {
     super(), ["change"].forEach((e) => {
       this.serialRegisterAvailableListener(e);
@@ -64,10 +63,10 @@ const w = class a extends P {
   static add(e) {
     const t = e.typeDevice;
     typeof a.devices[t] > "u" && a.registerType(t);
-    const n = e.uuid;
-    if (typeof a.devices[t] > "u" && a.typeError(t), a.devices[t][n])
-      throw new Error(`Device with id ${n} already exists`);
-    return a.devices[t][n] = e, a.$dispatchChange(e), Object.keys(a.devices[t]).indexOf(n);
+    const i = e.uuid;
+    if (typeof a.devices[t] > "u" && a.typeError(t), a.devices[t][i])
+      throw new Error(`Device with id ${i} already exists`);
+    return a.devices[t][i] = e, a.$dispatchChange(e), Object.keys(a.devices[t]).indexOf(i);
   }
   static get(e, t) {
     return typeof a.devices[e] > "u" && a.registerType(e), typeof a.devices[e] > "u" && a.typeError(e), a.devices[e][t];
@@ -79,10 +78,10 @@ const w = class a extends P {
     return Object.values(a.devices).map((e) => Object.values(e)).flat();
   }
   static getByNumber(e, t) {
-    return typeof a.devices[e] > "u" && a.typeError(e), Object.values(a.devices[e]).find((n) => n.deviceNumber === t) ?? null;
+    return typeof a.devices[e] > "u" && a.typeError(e), Object.values(a.devices[e]).find((i) => i.deviceNumber === t) ?? null;
   }
   static getCustom(e, t = 1) {
-    return typeof a.devices[e] > "u" && a.typeError(e), Object.values(a.devices[e]).find((n) => n.deviceNumber === t) ?? null;
+    return typeof a.devices[e] > "u" && a.typeError(e), Object.values(a.devices[e]).find((i) => i.deviceNumber === t) ?? null;
   }
   static async connectToAll() {
     const e = a.getList();
@@ -117,18 +116,18 @@ const w = class a extends P {
     return Promise.resolve(e.filter((t) => t.isDisconnected));
   }
 };
-g(w, "instance"), g(w, "devices", {});
-let c = w;
+y(C, "instance"), y(C, "devices", {});
+let c = C;
 c.instance || (c.instance = new c());
-function U(i = 100) {
+function M(n = 100) {
   return new Promise(
-    (e) => setTimeout(() => e(), i)
+    (e) => setTimeout(() => e(), n)
   );
 }
-function V() {
+function G() {
   return "serial" in navigator;
 }
-const b = {
+const v = {
   baudRate: 9600,
   dataBits: 8,
   stopBits: 1,
@@ -136,22 +135,22 @@ const b = {
   bufferSize: 32768,
   flowControl: "none"
 };
-var r, p, y, $, v, T, u, R, E, S, A, k, I, f, M, q, N, L, D, O, H;
-class z extends P {
+var p, r, f, m, q, x, k, u, N, L, D, B, P, O, g, H, j, F, U, $, W, Q;
+class K extends I {
   constructor({
     filters: e = null,
-    config_port: t = b,
-    no_device: n = 1,
+    config_port: t = v,
+    no_device: i = 1,
     device_listen_on_channel: s = 1,
     bypassSerialBytesConnection: o = !1
   } = {
     filters: null,
-    config_port: b,
+    config_port: v,
     no_device: 1,
     device_listen_on_channel: 1,
     bypassSerialBytesConnection: !1
   }) {
-    if (super(), Q(this, r), g(this, "__internal__", {
+    if (super(), S(this, r), y(this, "__internal__", {
       bypassSerialBytesConnection: !1,
       auto_response: !1,
       device_number: 1,
@@ -188,7 +187,7 @@ class z extends P {
         delay_first_connection: 200,
         bytes_connection: null,
         filters: [],
-        config_port: b,
+        config_port: v,
         queue: [],
         auto_response: ["DD", "DD"],
         free_timeout_ms: 50,
@@ -211,9 +210,9 @@ class z extends P {
       interval: {
         reconnection: 0
       }
-    }), !("serial" in navigator))
+    }), S(this, p, null), !("serial" in navigator))
       throw new Error("Web Serial not supported");
-    e && (this.serialFilters = e), t && (this.serialConfigPort = t), o && (this.__internal__.bypassSerialBytesConnection = o), n && l(this, r, O).call(this, n), s && ["number", "string"].includes(typeof s) && (this.listenOnChannel = s), l(this, r, q).call(this), l(this, r, N).call(this);
+    e && (this.serialFilters = e), t && (this.serialConfigPort = t), o && (this.__internal__.bypassSerialBytesConnection = o), i && l(this, r, W).call(this, i), s && ["number", "string"].includes(typeof s) && (this.listenOnChannel = s), l(this, r, j).call(this), l(this, r, F).call(this);
   }
   set listenOnChannel(e) {
     if (typeof e == "string" && (e = parseInt(e)), isNaN(e) || e < 1 || e > 255)
@@ -247,15 +246,15 @@ class z extends P {
     this.__internal__.serial.useRTSCTS = e;
   }
   get isConnected() {
-    const e = this.__internal__.serial.connected, t = l(this, r, p).call(this, this.__internal__.serial.port);
-    return e && !t && l(this, r, y).call(this, { error: "Port is closed, not readable or writable." }), this.__internal__.serial.connected = t, this.__internal__.serial.connected;
+    const e = this.__internal__.serial.connected, t = l(this, r, f).call(this, this.__internal__.serial.port);
+    return e && !t && l(this, r, m).call(this, { error: "Port is closed, not readable or writable." }), this.__internal__.serial.connected = t, this.__internal__.serial.connected;
   }
   get isConnecting() {
     return this.__internal__.serial.connecting;
   }
   get isDisconnected() {
-    const e = this.__internal__.serial.connected, t = l(this, r, p).call(this, this.__internal__.serial.port);
-    return !e && t && (this.dispatch("serial:connected"), l(this, r, f).call(this, !1), c.$dispatchChange(this)), this.__internal__.serial.connected = t, !this.__internal__.serial.connected;
+    const e = this.__internal__.serial.connected, t = l(this, r, f).call(this, this.__internal__.serial.port);
+    return !e && t && (this.dispatch("serial:connected"), l(this, r, g).call(this, !1), c.$dispatchChange(this)), this.__internal__.serial.connected = t, !this.__internal__.serial.connected;
   }
   get deviceNumber() {
     return this.__internal__.device_number;
@@ -333,15 +332,13 @@ class z extends P {
     });
   }
   async disconnect(e = null) {
-    await this.serialDisconnect(), l(this, r, y).call(this, e);
+    await this.serialDisconnect(), l(this, r, m).call(this, e);
   }
   async connect() {
     return this.isConnected ? !0 : (this.__internal__.serial.aux_connecting = "idle", new Promise((e, t) => {
-      V() || t("Web Serial not supported");
-      const n = l(this, r, $).bind(this);
-      this.on("serial:connecting", n);
-      const s = setInterval(() => {
-        this.__internal__.serial.aux_connecting === "finished" ? (clearInterval(s), this.__internal__.serial.aux_connecting = "idle", this.off("serial:connecting", n), this.isConnected ? e(!0) : t(`${this.typeDevice} device ${this.deviceNumber} not connected`)) : this.__internal__.serial.aux_connecting === "connecting" && (this.__internal__.serial.aux_connecting = "idle", this.dispatch("serial:connecting", { active: !0 }));
+      G() || t("Web Serial not supported"), b(this, p) || J(this, p, l(this, r, q).bind(this)), this.on("internal:connecting", b(this, p));
+      const i = setInterval(() => {
+        this.__internal__.serial.aux_connecting === "finished" ? (clearInterval(i), this.__internal__.serial.aux_connecting = "idle", b(this, p) !== null && this.off("internal:connecting", b(this, p)), this.isConnected ? e(!0) : t(`${this.typeDevice} device ${this.deviceNumber} not connected`)) : this.__internal__.serial.aux_connecting === "connecting" && (this.__internal__.serial.aux_connecting = "idle", this.dispatch("internal:connecting", { active: !0 }), this.dispatch("serial:connecting", { active: !0 }));
       }, 100);
       this.serialConnect();
     }));
@@ -349,7 +346,7 @@ class z extends P {
   async serialDisconnect() {
     try {
       const e = this.__internal__.serial.reader, t = this.__internal__.serial.output_stream;
-      e && (await e.cancel().catch((n) => this.serialErrors(n)), await this.__internal__.serial.input_done), t && (await t.getWriter().close(), await this.__internal__.serial.output_done), this.__internal__.serial.connected && this.__internal__.serial && this.__internal__.serial.port && await this.__internal__.serial.port.close();
+      e && (await e.cancel().catch((i) => this.serialErrors(i)), await this.__internal__.serial.input_done), t && (await t.getWriter().close(), await this.__internal__.serial.output_done), this.__internal__.serial.connected && this.__internal__.serial && this.__internal__.serial.port && await this.__internal__.serial.port.close();
     } catch (e) {
       this.serialErrors(e);
     } finally {
@@ -371,8 +368,8 @@ class z extends P {
   async serialPortsSaved(e) {
     const t = this.serialFilters;
     if (this.__internal__.aux_port_connector < e.length) {
-      const n = this.__internal__.aux_port_connector;
-      this.__internal__.serial.port = e[n];
+      const i = this.__internal__.aux_port_connector;
+      this.__internal__.serial.port = e[i];
     } else
       this.__internal__.aux_port_connector = 0, this.__internal__.serial.port = await navigator.serial.requestPort({
         filters: t
@@ -429,8 +426,8 @@ class z extends P {
   }
   async serialConnect() {
     try {
-      l(this, r, f).call(this, !0);
-      const e = await l(this, r, R).call(this);
+      l(this, r, g).call(this, !0);
+      const e = await l(this, r, N).call(this);
       if (e.length > 0)
         await this.serialPortsSaved(e);
       else {
@@ -443,24 +440,24 @@ class z extends P {
       if (!t)
         throw new Error("No port selected by the user");
       await t.open(this.serialConfigPort);
-      const n = this;
+      const i = this;
       t.onconnect = (s) => {
         var o;
-        n.dispatch("serial:connected", s), l(o = n, r, f).call(o, !1), c.$dispatchChange(this), n.__internal__.serial.queue.length > 0 && n.dispatch("internal:queue", {});
+        i.dispatch("serial:connected", s), l(o = i, r, g).call(o, !1), c.$dispatchChange(this), i.__internal__.serial.queue.length > 0 && i.dispatch("internal:queue", {});
       }, t.ondisconnect = async () => {
-        await n.disconnect();
-      }, await U(this.__internal__.serial.delay_first_connection), this.__internal__.timeout.until_response = setTimeout(async () => {
-        await n.timeout(n.__internal__.serial.bytes_connection ?? [], "connection:start");
-      }, this.__internal__.time.response_connection), this.__internal__.serial.last_action = "connect", await l(this, r, v).call(this, this.__internal__.serial.bytes_connection ?? []), this.dispatch("serial:sent", {
+        await i.disconnect();
+      }, await M(this.__internal__.serial.delay_first_connection), this.__internal__.timeout.until_response = setTimeout(async () => {
+        await i.timeout(i.__internal__.serial.bytes_connection ?? [], "connection:start");
+      }, this.__internal__.time.response_connection), this.__internal__.serial.last_action = "connect", await l(this, r, x).call(this, this.__internal__.serial.bytes_connection ?? []), this.dispatch("serial:sent", {
         action: "connect",
         bytes: this.__internal__.serial.bytes_connection
-      }), this.__internal__.auto_response && l(this, r, u).call(this, this.__internal__.serial.auto_response), await l(this, r, I).call(this);
+      }), this.__internal__.auto_response && l(this, r, u).call(this, this.__internal__.serial.auto_response), await l(this, r, O).call(this);
     } catch (e) {
-      l(this, r, f).call(this, !1), this.serialErrors(e);
+      l(this, r, g).call(this, !1), this.serialErrors(e);
     }
   }
   async serialForget() {
-    return await l(this, r, M).call(this);
+    return await l(this, r, H).call(this);
   }
   decToHex(e) {
     return typeof e == "string" && (e = parseInt(e, 10)), e.toString(16);
@@ -473,8 +470,8 @@ class z extends P {
   }
   add0x(e) {
     const t = [];
-    return e.forEach((n, s) => {
-      t[s] = "0x" + n;
+    return e.forEach((i, s) => {
+      t[s] = "0x" + i;
     }), t;
   }
   bytesToHex(e) {
@@ -495,13 +492,13 @@ class z extends P {
     return t;
   }
   async appendToQueue(e, t) {
-    const n = this.validateBytes(e);
+    const i = this.validateBytes(e);
     if (["connect", "connection:start"].includes(t)) {
       if (this.__internal__.serial.connected) return;
       await this.serialConnect();
       return;
     }
-    this.__internal__.serial.queue.push({ bytes: n, action: t }), this.dispatch("internal:queue", {});
+    this.__internal__.serial.queue.push({ bytes: i, action: t }), this.dispatch("internal:queue", {});
   }
   serialSetConnectionConstant(e = 1) {
     if (this.__internal__.bypassSerialBytesConnection) return this.__internal__.serial.bytes_connection;
@@ -518,8 +515,8 @@ class z extends P {
   }
   sumHex(e) {
     let t = 0;
-    return e.forEach((n) => {
-      t += parseInt(n, 16);
+    return e.forEach((i) => {
+      t += parseInt(i, 16);
     }), t.toString(16);
   }
   toString() {
@@ -532,7 +529,7 @@ class z extends P {
     });
   }
   softReload() {
-    l(this, r, H).call(this), this.dispatch("serial:soft-reload", {});
+    l(this, r, Q).call(this), this.dispatch("serial:soft-reload", {});
   }
   async sendConnect() {
     if (!this.__internal__.serial.bytes_connection)
@@ -553,13 +550,13 @@ class z extends P {
   }
   parseStringToTextEncoder(e = "", t = `
 `) {
-    const n = new TextEncoder();
-    return e += t, n.encode(e);
+    const i = new TextEncoder();
+    return e += t, i.encode(e);
   }
   parseStringToBytes(e = "", t = `
 `) {
-    const n = this.parseStringToTextEncoder(e, t);
-    return Array.from(n).map((s) => s.toString(16));
+    const i = this.parseStringToTextEncoder(e, t);
+    return Array.from(i).map((s) => s.toString(16));
   }
   parseUint8ToHex(e) {
     return Array.from(e).map((t) => t.toString(16));
@@ -569,28 +566,28 @@ class z extends P {
   }
   stringArrayToUint8Array(e) {
     const t = [];
-    return typeof e == "string" ? this.parseStringToTextEncoder(e).buffer : (e.forEach((n) => {
-      const s = n.replace("0x", "");
+    return typeof e == "string" ? this.parseStringToTextEncoder(e).buffer : (e.forEach((i) => {
+      const s = i.replace("0x", "");
       t.push(parseInt(s, 16));
     }), new Uint8Array(t));
   }
   parseUint8ArrayToString(e) {
     let t = new Uint8Array(0);
     e instanceof Uint8Array ? t = e : t = this.stringArrayToUint8Array(e), e = this.parseUint8ToHex(t);
-    const n = e.map((s) => parseInt(s, 16));
-    return this.__internal__.serial.response.replacer ? String.fromCharCode(...n).replace(this.__internal__.serial.response.replacer, "") : String.fromCharCode(...n);
+    const i = e.map((s) => parseInt(s, 16));
+    return this.__internal__.serial.response.replacer ? String.fromCharCode(...i).replace(this.__internal__.serial.response.replacer, "") : String.fromCharCode(...i);
   }
   hexToAscii(e) {
     const t = e.toString();
-    let n = "";
+    let i = "";
     for (let s = 0; s < t.length; s += 2)
-      n += String.fromCharCode(parseInt(t.substring(s, 2), 16));
-    return n;
+      i += String.fromCharCode(parseInt(t.substring(s, 2), 16));
+    return i;
   }
   asciiToHex(e) {
     const t = [];
-    for (let n = 0, s = e.length; n < s; n++) {
-      const o = Number(e.charCodeAt(n)).toString(16);
+    for (let i = 0, s = e.length; i < s; i++) {
+      const o = Number(e.charCodeAt(i)).toString(16);
       t.push(o);
     }
     return t.join("");
@@ -599,151 +596,151 @@ class z extends P {
     return this.isConnected;
   }
 }
-r = /* @__PURE__ */ new WeakSet(), p = function(i) {
-  return !!(i && i.readable && i.writable);
-}, y = function(i = null) {
-  this.__internal__.serial.connected = !1, this.__internal__.aux_port_connector = 0, this.dispatch("serial:disconnected", i), c.$dispatchChange(this);
-}, $ = function(i) {
-  this.__internal__.serial.aux_connecting = i.detail.active ? "connecting" : "finished";
-}, v = async function(i) {
+p = /* @__PURE__ */ new WeakMap(), r = /* @__PURE__ */ new WeakSet(), f = function(n) {
+  return !!(n && n.readable && n.writable);
+}, m = function(n = null) {
+  this.__internal__.serial.connected = !1, this.__internal__.aux_port_connector = 0, this.dispatch("serial:disconnected", n), c.$dispatchChange(this);
+}, q = function(n) {
+  this.__internal__.serial.aux_connecting = n.detail.active ? "connecting" : "finished";
+}, x = async function(n) {
   const e = this.__internal__.serial.port;
   if (!e || e && (!e.readable || !e.writable))
-    throw l(this, r, y).call(this, { error: "Port is closed, not readable or writable." }), new Error("The port is closed or is not readable/writable");
-  const t = this.validateBytes(i);
-  if (this.useRTSCTS && await l(this, r, T).call(this, e, 5e3), e.writable === null) return;
-  const n = e.writable.getWriter();
-  await n.write(t), n.releaseLock();
-}, T = async function(i, e = 5e3) {
+    throw l(this, r, m).call(this, { error: "Port is closed, not readable or writable." }), new Error("The port is closed or is not readable/writable");
+  const t = this.validateBytes(n);
+  if (this.useRTSCTS && await l(this, r, k).call(this, e, 5e3), e.writable === null) return;
+  const i = e.writable.getWriter();
+  await i.write(t), i.releaseLock();
+}, k = async function(n, e = 5e3) {
   const t = Date.now();
   for (; ; ) {
     if (Date.now() - t > e)
       throw new Error("Timeout waiting for clearToSend signal");
-    const { clearToSend: n } = await i.getSignals();
-    if (n) return;
-    await U(100);
+    const { clearToSend: i } = await n.getSignals();
+    if (i) return;
+    await M(100);
   }
-}, u = function(i = new Uint8Array([]), e = !1) {
-  if (i && i.length > 0) {
+}, u = function(n = new Uint8Array([]), e = !1) {
+  if (n && n.length > 0) {
     const t = this.__internal__.serial.connected;
-    if (this.__internal__.serial.connected = l(this, r, p).call(this, this.__internal__.serial.port), c.$dispatchChange(this), !t && this.__internal__.serial.connected && (this.dispatch("serial:connected"), l(this, r, f).call(this, !1)), this.__internal__.interval.reconnection && (clearInterval(this.__internal__.interval.reconnection), this.__internal__.interval.reconnection = 0), this.__internal__.timeout.until_response && (clearTimeout(this.__internal__.timeout.until_response), this.__internal__.timeout.until_response = 0), this.__internal__.serial.response.as === "hex")
-      e ? this.serialCorruptMessage(this.parseUint8ToHex(i)) : this.serialMessage(this.parseUint8ToHex(i));
+    if (this.__internal__.serial.connected = l(this, r, f).call(this, this.__internal__.serial.port), c.$dispatchChange(this), !t && this.__internal__.serial.connected && (this.dispatch("serial:connected"), l(this, r, g).call(this, !1)), this.__internal__.interval.reconnection && (clearInterval(this.__internal__.interval.reconnection), this.__internal__.interval.reconnection = 0), this.__internal__.timeout.until_response && (clearTimeout(this.__internal__.timeout.until_response), this.__internal__.timeout.until_response = 0), this.__internal__.serial.response.as === "hex")
+      e ? this.serialCorruptMessage(this.parseUint8ToHex(n)) : this.serialMessage(this.parseUint8ToHex(n));
     else if (this.__internal__.serial.response.as === "uint8")
-      e ? this.serialCorruptMessage(i) : this.serialMessage(i);
+      e ? this.serialCorruptMessage(n) : this.serialMessage(n);
     else if (this.__internal__.serial.response.as === "string") {
-      const n = this.parseUint8ArrayToString(i);
+      const i = this.parseUint8ArrayToString(n);
       if (this.__internal__.serial.response.limiter !== null) {
-        const s = n.split(this.__internal__.serial.response.limiter);
+        const s = i.split(this.__internal__.serial.response.limiter);
         for (const o in s)
           s[o] && (e ? this.serialCorruptMessage(s[o]) : this.serialMessage(s[o]));
       } else
-        e ? this.serialCorruptMessage(n) : this.serialMessage(n);
+        e ? this.serialCorruptMessage(i) : this.serialMessage(i);
     } else {
-      const n = this.stringToArrayBuffer(this.parseUint8ArrayToString(i));
-      e ? this.serialCorruptMessage(n) : this.serialMessage(n);
+      const i = this.stringToArrayBuffer(this.parseUint8ArrayToString(n));
+      e ? this.serialCorruptMessage(i) : this.serialMessage(i);
     }
   }
   this.__internal__.serial.queue.length !== 0 && this.dispatch("internal:queue", {});
-}, R = async function() {
-  const i = this.serialFilters, e = await navigator.serial.getPorts({ filters: i });
-  return i.length === 0 ? e : e.filter((t) => {
-    const n = t.getInfo();
-    return i.some((s) => n.usbProductId === s.usbProductId && n.usbVendorId === s.usbVendorId);
-  }).filter((t) => !l(this, r, p).call(this, t));
-}, E = function(i) {
-  if (i) {
-    const e = this.__internal__.serial.response.buffer, t = new Uint8Array(e.length + i.byteLength);
-    t.set(e, 0), t.set(new Uint8Array(i), e.length), this.__internal__.serial.response.buffer = t;
-  }
-}, S = async function() {
+}, N = async function() {
+  const n = this.serialFilters, e = await navigator.serial.getPorts({ filters: n });
+  return n.length === 0 ? e : e.filter((t) => {
+    const i = t.getInfo();
+    return n.some((s) => i.usbProductId === s.usbProductId && i.usbVendorId === s.usbVendorId);
+  }).filter((t) => !l(this, r, f).call(this, t));
+}, L = function(n) {
+  if (n) {
+    const e = this.__internal__.serial.response.buffer, t = new Uint8Array(e.length + n.byteLength);
+    t.set(e, 0), t.set(new Uint8Array(n), e.length), this.__internal__.serial.response.buffer = t;
+  }
+}, D = async function() {
   this.__internal__.serial.time_until_send_bytes && (clearTimeout(this.__internal__.serial.time_until_send_bytes), this.__internal__.serial.time_until_send_bytes = 0), this.__internal__.serial.time_until_send_bytes = setTimeout(() => {
     this.__internal__.serial.response.buffer && l(this, r, u).call(this, this.__internal__.serial.response.buffer), this.__internal__.serial.response.buffer = new Uint8Array(0);
   }, this.__internal__.serial.free_timeout_ms || 50);
-}, A = async function() {
-  const i = this.__internal__.serial.response.length;
+}, B = async function() {
+  const n = this.__internal__.serial.response.length;
   let e = this.__internal__.serial.response.buffer;
-  if (this.__internal__.serial.time_until_send_bytes && (clearTimeout(this.__internal__.serial.time_until_send_bytes), this.__internal__.serial.time_until_send_bytes = 0), !(i === null || !e || e.length === 0)) {
-    for (; e.length >= i; ) {
-      const t = e.slice(0, i);
-      l(this, r, u).call(this, t), e = e.slice(i);
+  if (this.__internal__.serial.time_until_send_bytes && (clearTimeout(this.__internal__.serial.time_until_send_bytes), this.__internal__.serial.time_until_send_bytes = 0), !(n === null || !e || e.length === 0)) {
+    for (; e.length >= n; ) {
+      const t = e.slice(0, n);
+      l(this, r, u).call(this, t), e = e.slice(n);
     }
     this.__internal__.serial.response.buffer = e, e.length > 0 && (this.__internal__.serial.time_until_send_bytes = setTimeout(() => {
       l(this, r, u).call(this, this.__internal__.serial.response.buffer, !0);
     }, this.__internal__.serial.free_timeout_ms || 50));
   }
-}, k = async function() {
+}, P = async function() {
   const {
-    limiter: i,
+    limiter: n,
     prefixLimiter: e = !1,
     sufixLimiter: t = !0
   } = this.__internal__.serial.response;
-  if (!i)
+  if (!n)
     throw new Error("No limiter defined for delimited serial response");
-  const n = this.__internal__.serial.response.buffer;
-  if (!i || !n || n.length === 0) return;
+  const i = this.__internal__.serial.response.buffer;
+  if (!n || !i || i.length === 0) return;
   this.__internal__.serial.time_until_send_bytes && (clearTimeout(this.__internal__.serial.time_until_send_bytes), this.__internal__.serial.time_until_send_bytes = 0);
-  let s = new TextDecoder().decode(n);
+  let s = new TextDecoder().decode(i);
   const o = [];
-  if (typeof i == "string") {
+  if (typeof n == "string") {
     let _;
     if (e && t)
-      _ = new RegExp(`${i}([^${i}]+)${i}`, "g");
+      _ = new RegExp(`${n}([^${n}]+)${n}`, "g");
     else if (e)
-      _ = new RegExp(`${i}([^${i}]*)`, "g");
+      _ = new RegExp(`${n}([^${n}]*)`, "g");
     else if (t)
-      _ = new RegExp(`([^${i}]+)${i}`, "g");
+      _ = new RegExp(`([^${n}]+)${n}`, "g");
     else
       return;
     let d, h = 0;
     for (; (d = _.exec(s)) !== null; )
       o.push(new TextEncoder().encode(d[1])), h = _.lastIndex;
     s = s.slice(h);
-  } else if (i instanceof RegExp) {
+  } else if (n instanceof RegExp) {
     let _, d = 0;
     if (e && t) {
-      const h = new RegExp(`${i.source}(.*?)${i.source}`, "g");
+      const h = new RegExp(`${n.source}(.*?)${n.source}`, "g");
       for (; (_ = h.exec(s)) !== null; )
         o.push(new TextEncoder().encode(_[1])), d = h.lastIndex;
     } else if (t)
-      for (; (_ = i.exec(s)) !== null; ) {
-        const h = _.index, m = s.slice(d, h);
-        o.push(new TextEncoder().encode(m)), d = i.lastIndex;
+      for (; (_ = n.exec(s)) !== null; ) {
+        const h = _.index, w = s.slice(d, h);
+        o.push(new TextEncoder().encode(w)), d = n.lastIndex;
       }
     else if (e) {
-      const h = s.split(i);
+      const h = s.split(n);
       h.shift();
-      for (const m of h)
-        o.push(new TextEncoder().encode(m));
+      for (const w of h)
+        o.push(new TextEncoder().encode(w));
       s = "";
     }
     s = s.slice(d);
   }
   for (const _ of o)
     l(this, r, u).call(this, _);
-  const C = new TextEncoder().encode(s);
-  this.__internal__.serial.response.buffer = C, C.length > 0 && (this.__internal__.serial.time_until_send_bytes = setTimeout(() => {
+  const E = new TextEncoder().encode(s);
+  this.__internal__.serial.response.buffer = E, E.length > 0 && (this.__internal__.serial.time_until_send_bytes = setTimeout(() => {
     l(this, r, u).call(this, this.__internal__.serial.response.buffer, !0), this.__internal__.serial.response.buffer = new Uint8Array(0);
   }, this.__internal__.serial.free_timeout_ms ?? 50));
-}, I = async function() {
-  const i = this.__internal__.serial.port;
-  if (!i || !i.readable) throw new Error("Port is not readable");
-  const e = i.readable.getReader();
+}, O = async function() {
+  const n = this.__internal__.serial.port;
+  if (!n || !n.readable) throw new Error("Port is not readable");
+  const e = n.readable.getReader();
   this.__internal__.serial.reader = e;
   try {
     for (; this.__internal__.serial.keep_reading; ) {
-      const { value: t, done: n } = await e.read();
-      if (n) break;
-      l(this, r, E).call(this, t), this.__internal__.serial.response.delimited ? await l(this, r, k).call(this) : this.__internal__.serial.response.length === null ? await l(this, r, S).call(this) : await l(this, r, A).call(this);
+      const { value: t, done: i } = await e.read();
+      if (i) break;
+      l(this, r, L).call(this, t), this.__internal__.serial.response.delimited ? await l(this, r, P).call(this) : this.__internal__.serial.response.length === null ? await l(this, r, D).call(this) : await l(this, r, B).call(this);
     }
   } catch (t) {
     this.serialErrors(t);
   } finally {
     e.releaseLock(), this.__internal__.serial.keep_reading = !0, this.__internal__.serial.port && await this.__internal__.serial.port.close();
   }
-}, f = function(i) {
-  i !== this.__internal__.serial.connecting && (this.__internal__.serial.connecting = i, i ? this.dispatch("serial:connecting", { active: !0 }) : this.dispatch("serial:connecting", { active: !1 }));
-}, M = async function() {
+}, g = function(n) {
+  n !== this.__internal__.serial.connecting && (this.__internal__.serial.connecting = n, this.dispatch("serial:connecting", { active: n }), this.dispatch("internal:connecting", { active: n }));
+}, H = async function() {
   return typeof window > "u" ? !1 : "serial" in navigator && "forget" in SerialPort.prototype && this.__internal__.serial.port ? (await this.__internal__.serial.port.forget(), !0) : !1;
-}, q = function() {
+}, j = function() {
   [
     "serial:connected",
     "serial:connecting",
@@ -760,48 +757,48 @@ r = /* @__PURE__ */ new WeakSet(), p = function(i) {
     "serial:unsupported",
     "serial:error",
     "debug"
-  ].forEach((i) => {
-    this.serialRegisterAvailableListener(i);
+  ].forEach((n) => {
+    this.serialRegisterAvailableListener(n);
   });
-}, N = function() {
-  const i = this;
+}, F = function() {
+  const n = this;
   this.on("internal:queue", async () => {
     var e;
-    await l(e = i, r, D).call(e);
-  }), l(this, r, L).call(this);
-}, L = function() {
-  const i = this;
+    await l(e = n, r, $).call(e);
+  }), l(this, r, U).call(this);
+}, U = function() {
+  const n = this;
   navigator.serial.addEventListener("connect", async () => {
-    i.isDisconnected && await i.serialConnect().catch(() => {
+    n.isDisconnected && await n.serialConnect().catch(() => {
     });
   });
-}, D = async function() {
-  if (!l(this, r, p).call(this, this.__internal__.serial.port)) {
-    l(this, r, y).call(this, { error: "Port is closed, not readable or writable." }), await this.serialConnect();
+}, $ = async function() {
+  if (!l(this, r, f).call(this, this.__internal__.serial.port)) {
+    l(this, r, m).call(this, { error: "Port is closed, not readable or writable." }), await this.serialConnect();
     return;
   }
   if (this.__internal__.timeout.until_response || this.__internal__.serial.queue.length === 0) return;
-  const i = this.__internal__.serial.queue[0];
+  const n = this.__internal__.serial.queue[0];
   let e = this.__internal__.time.response_general;
-  if (i.action === "connect" && (e = this.__internal__.time.response_connection), this.__internal__.timeout.until_response = setTimeout(async () => {
-    await this.timeout(i.bytes, i.action);
-  }, e), this.__internal__.serial.last_action = i.action ?? "unknown", await l(this, r, v).call(this, i.bytes), this.dispatch("serial:sent", {
-    action: i.action,
-    bytes: i.bytes
+  if (n.action === "connect" && (e = this.__internal__.time.response_connection), this.__internal__.timeout.until_response = setTimeout(async () => {
+    await this.timeout(n.bytes, n.action);
+  }, e), this.__internal__.serial.last_action = n.action ?? "unknown", await l(this, r, x).call(this, n.bytes), this.dispatch("serial:sent", {
+    action: n.action,
+    bytes: n.bytes
   }), this.__internal__.auto_response) {
-    let n = new Uint8Array(0);
+    let i = new Uint8Array(0);
     try {
-      n = this.validateBytes(this.__internal__.serial.auto_response);
+      i = this.validateBytes(this.__internal__.serial.auto_response);
     } catch (s) {
       this.serialErrors(s);
     }
-    l(this, r, u).call(this, n);
+    l(this, r, u).call(this, i);
   }
   const t = [...this.__internal__.serial.queue];
   this.__internal__.serial.queue = t.splice(1);
-}, O = function(i = 1) {
-  this.__internal__.device_number = i, !this.__internal__.bypassSerialBytesConnection && (this.__internal__.serial.bytes_connection = this.serialSetConnectionConstant(i));
-}, H = function() {
+}, W = function(n = 1) {
+  this.__internal__.device_number = n, !this.__internal__.bypassSerialBytesConnection && (this.__internal__.serial.bytes_connection = this.serialSetConnectionConstant(n));
+}, Q = function() {
   this.__internal__.last_error = {
     message: null,
     action: null,
@@ -810,6 +807,6 @@ r = /* @__PURE__ */ new WeakSet(), p = function(i) {
   };
 };
 export {
-  z as K,
+  K as Z,
   c as h
 };