@danidoble/webserial 4.3.10 → 4.3.12

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

@@ -1,20 +1,17 @@
-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 {
+class p extends CustomEvent {
   constructor(e, t) {
     super(e, t);
   }
 }
-class I extends EventTarget {
-  constructor() {
-    super(...arguments), y(this, "__listeners__", {
-      debug: !1
-    }), y(this, "__debug__", !1), y(this, "__listenersCallbacks__", []);
-  }
+class g extends EventTarget {
+  __listeners__ = {
+    debug: !1
+  };
+  __debug__ = !1;
+  __listenersCallbacks__ = [];
   dispatch(e, t = null) {
-    const i = new A(e, { detail: t });
-    this.dispatchEvent(i), this.__debug__ && this.dispatchEvent(new A("debug", { detail: { type: e, data: t } }));
+    const i = new p(e, { detail: t });
+    this.dispatchEvent(i), this.__debug__ && this.dispatchEvent(new p("debug", { detail: { type: e, data: t } }));
   }
   dispatchAsync(e, t = null, i = 100) {
     const s = this;
@@ -44,90 +41,90 @@ class I extends EventTarget {
       this.__listeners__[e] = !1;
   }
 }
-const C = class a extends I {
+class n extends g {
+  static instance;
+  static devices = {};
   constructor() {
     super(), ["change"].forEach((e) => {
       this.serialRegisterAvailableListener(e);
     });
   }
   static $dispatchChange(e = null) {
-    e && e.$checkAndDispatchConnection(), a.instance.dispatch("change", { devices: a.devices, dispatcher: e });
+    e && e.$checkAndDispatchConnection(), n.instance.dispatch("change", { devices: n.devices, dispatcher: e });
   }
   static typeError(e) {
     const t = new Error();
     throw t.message = `Type ${e} is not supported`, t.name = "DeviceTypeError", t;
   }
   static registerType(e) {
-    typeof a.devices[e] > "u" && (a.devices = { ...a.devices, [e]: {} });
+    typeof n.devices[e] > "u" && (n.devices = { ...n.devices, [e]: {} });
   }
   static add(e) {
     const t = e.typeDevice;
-    typeof a.devices[t] > "u" && a.registerType(t);
+    typeof n.devices[t] > "u" && n.registerType(t);
     const i = e.uuid;
-    if (typeof a.devices[t] > "u" && a.typeError(t), a.devices[t][i])
+    if (typeof n.devices[t] > "u" && n.typeError(t), n.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);
+    return n.devices[t][i] = e, n.$dispatchChange(e), Object.keys(n.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];
+    return typeof n.devices[e] > "u" && n.registerType(e), typeof n.devices[e] > "u" && n.typeError(e), n.devices[e][t];
   }
   static getAll(e = null) {
-    return e === null ? a.devices : (typeof a.devices[e] > "u" && a.typeError(e), a.devices[e]);
+    return e === null ? n.devices : (typeof n.devices[e] > "u" && n.typeError(e), n.devices[e]);
   }
   static getList() {
-    return Object.values(a.devices).map((e) => Object.values(e)).flat();
+    return Object.values(n.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((i) => i.deviceNumber === t) ?? null;
+    return typeof n.devices[e] > "u" && n.typeError(e), Object.values(n.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((i) => i.deviceNumber === t) ?? null;
+    return typeof n.devices[e] > "u" && n.typeError(e), Object.values(n.devices[e]).find((i) => i.deviceNumber === t) ?? null;
   }
   static async connectToAll() {
-    const e = a.getList();
+    const e = n.getList();
     for (const t of e)
       t.isConnected || await t.connect().catch(console.warn);
-    return Promise.resolve(a.areAllConnected());
+    return Promise.resolve(n.areAllConnected());
   }
   static async disconnectAll() {
-    const e = a.getList();
+    const e = n.getList();
     for (const t of e)
       t.isDisconnected || await t.disconnect().catch(console.warn);
-    return Promise.resolve(a.areAllDisconnected());
+    return Promise.resolve(n.areAllDisconnected());
   }
   static async areAllConnected() {
-    const e = a.getList();
+    const e = n.getList();
     for (const t of e)
       if (!t.isConnected) return Promise.resolve(!1);
     return Promise.resolve(!0);
   }
   static async areAllDisconnected() {
-    const e = a.getList();
+    const e = n.getList();
     for (const t of e)
       if (!t.isDisconnected) return Promise.resolve(!1);
     return Promise.resolve(!0);
   }
   static async getAllConnected() {
-    const e = a.getList();
+    const e = n.getList();
     return Promise.resolve(e.filter((t) => t.isConnected));
   }
   static async getAllDisconnected() {
-    const e = a.getList();
+    const e = n.getList();
     return Promise.resolve(e.filter((t) => t.isDisconnected));
   }
-};
-y(C, "instance"), y(C, "devices", {});
-let c = C;
-c.instance || (c.instance = new c());
-function M(n = 100) {
+}
+n.instance || (n.instance = new n());
+function f(c = 100) {
   return new Promise(
-    (e) => setTimeout(() => e(), n)
+    (e) => setTimeout(() => e(), c)
   );
 }
-function G() {
+function y() {
   return "serial" in navigator;
 }
-const v = {
+const u = {
   baudRate: 9600,
   dataBits: 8,
   stopBits: 1,
@@ -135,84 +132,86 @@ const v = {
   bufferSize: 32768,
   flowControl: "none"
 };
-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 {
+class b extends g {
+  __internal__ = {
+    bypassSerialBytesConnection: !1,
+    auto_response: !1,
+    device_number: 1,
+    aux_port_connector: 0,
+    last_error: {
+      message: null,
+      action: null,
+      code: null,
+      no_code: 0
+    },
+    serial: {
+      aux_connecting: "idle",
+      connecting: !1,
+      connected: !1,
+      port: null,
+      last_action: null,
+      response: {
+        length: null,
+        buffer: new Uint8Array([]),
+        as: "uint8",
+        replacer: /[\n\r]+/g,
+        limiter: null,
+        prefixLimiter: !1,
+        sufixLimiter: !0,
+        delimited: !1
+      },
+      reader: null,
+      input_done: null,
+      output_done: null,
+      input_stream: null,
+      output_stream: null,
+      keep_reading: !0,
+      time_until_send_bytes: void 0,
+      delay_first_connection: 200,
+      bytes_connection: null,
+      filters: [],
+      config_port: u,
+      queue: [],
+      running_queue: !1,
+      auto_response: ["DD", "DD"],
+      free_timeout_ms: 50,
+      // In previous versions 400 was used
+      useRTSCTS: !1
+      // Use RTS/CTS flow control
+    },
+    device: {
+      type: "unknown",
+      id: window.crypto.randomUUID(),
+      listen_on_port: null
+    },
+    time: {
+      response_connection: 500,
+      response_general: 2e3
+    },
+    timeout: {
+      until_response: 0
+    },
+    interval: {
+      reconnection: 0
+    }
+  };
+  #t = null;
   constructor({
     filters: e = null,
-    config_port: t = v,
+    config_port: t = u,
     no_device: i = 1,
     device_listen_on_channel: s = 1,
-    bypassSerialBytesConnection: o = !1
+    bypassSerialBytesConnection: r = !1
   } = {
     filters: null,
-    config_port: v,
+    config_port: u,
     no_device: 1,
     device_listen_on_channel: 1,
     bypassSerialBytesConnection: !1
   }) {
-    if (super(), S(this, r), y(this, "__internal__", {
-      bypassSerialBytesConnection: !1,
-      auto_response: !1,
-      device_number: 1,
-      aux_port_connector: 0,
-      last_error: {
-        message: null,
-        action: null,
-        code: null,
-        no_code: 0
-      },
-      serial: {
-        aux_connecting: "idle",
-        connecting: !1,
-        connected: !1,
-        port: null,
-        last_action: null,
-        response: {
-          length: null,
-          buffer: new Uint8Array([]),
-          as: "uint8",
-          replacer: /[\n\r]+/g,
-          limiter: null,
-          prefixLimiter: !1,
-          sufixLimiter: !0,
-          delimited: !1
-        },
-        reader: null,
-        input_done: null,
-        output_done: null,
-        input_stream: null,
-        output_stream: null,
-        keep_reading: !0,
-        time_until_send_bytes: void 0,
-        delay_first_connection: 200,
-        bytes_connection: null,
-        filters: [],
-        config_port: v,
-        queue: [],
-        auto_response: ["DD", "DD"],
-        free_timeout_ms: 50,
-        // In previous versions 400 was used
-        useRTSCTS: !1
-        // Use RTS/CTS flow control
-      },
-      device: {
-        type: "unknown",
-        id: window.crypto.randomUUID(),
-        listen_on_port: null
-      },
-      time: {
-        response_connection: 500,
-        response_general: 2e3
-      },
-      timeout: {
-        until_response: 0
-      },
-      interval: {
-        reconnection: 0
-      }
-    }), S(this, p, null), !("serial" in navigator))
+    if (super(), !("serial" in navigator))
       throw new Error("Web Serial not supported");
-    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);
+    e && (this.serialFilters = e), t && (this.serialConfigPort = t), r && (this.__internal__.bypassSerialBytesConnection = r), i && this.#m(i), s && ["number", "string"].includes(typeof s) && (this.listenOnChannel = s), this.#f(), this.#g();
   }
   set listenOnChannel(e) {
     if (typeof e == "string" && (e = parseInt(e)), isNaN(e) || e < 1 || e > 255)
@@ -246,15 +245,15 @@ class K extends I {
     this.__internal__.serial.useRTSCTS = e;
   }
   get isConnected() {
-    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;
+    const e = this.__internal__.serial.connected, t = this.#i(this.__internal__.serial.port);
+    return e && !t && this.#s({ 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, 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;
+    const e = this.__internal__.serial.connected, t = this.#i(this.__internal__.serial.port);
+    return !e && t && (this.dispatch("serial:connected"), this.#n(!1), n.$dispatchChange(this)), this.__internal__.serial.connected = t, !this.__internal__.serial.connected;
   }
   get deviceNumber() {
     return this.__internal__.device_number;
@@ -324,21 +323,30 @@ class K extends I {
       throw new Error("bypassSerialBytesConnection must be a boolean");
     this.__internal__.bypassSerialBytesConnection = e;
   }
+  #i(e) {
+    return !!(e && e.readable && e.writable);
+  }
   async timeout(e, t) {
-    this.__internal__.last_error.message = "Operation response timed out.", this.__internal__.last_error.action = t, this.__internal__.last_error.code = e, this.__internal__.timeout.until_response && (clearTimeout(this.__internal__.timeout.until_response), this.__internal__.timeout.until_response = 0), t === "connect" ? (this.__internal__.serial.connected = !1, this.dispatch("serial:reconnect", {}), c.$dispatchChange(this)) : t === "connection:start" && (await this.serialDisconnect(), this.__internal__.serial.connected = !1, this.__internal__.aux_port_connector += 1, c.$dispatchChange(this), await this.serialConnect()), this.dispatch("serial:timeout", {
+    this.__internal__.last_error.message = "Operation response timed out.", this.__internal__.last_error.action = t, this.__internal__.last_error.code = e, this.__internal__.timeout.until_response && (clearTimeout(this.__internal__.timeout.until_response), this.__internal__.timeout.until_response = 0), t === "connect" ? (this.__internal__.serial.connected = !1, this.dispatch("serial:reconnect", {}), n.$dispatchChange(this)) : t === "connection:start" && (await this.serialDisconnect(), this.__internal__.serial.connected = !1, this.__internal__.aux_port_connector += 1, n.$dispatchChange(this), await this.serialConnect()), this.__internal__.serial.queue.length > 0 && this.dispatch("internal:queue", {}), this.dispatch("serial:timeout", {
       ...this.__internal__.last_error,
       bytes: e,
       action: t
     });
   }
   async disconnect(e = null) {
-    await this.serialDisconnect(), l(this, r, m).call(this, e);
+    await this.serialDisconnect(), this.#s(e);
+  }
+  #s(e = null) {
+    this.__internal__.serial.connected = !1, this.__internal__.aux_port_connector = 0, this.dispatch("serial:disconnected", e), n.$dispatchChange(this);
+  }
+  #a(e) {
+    this.__internal__.serial.aux_connecting = e.detail.active ? "connecting" : "finished";
   }
   async connect() {
     return this.isConnected ? !0 : (this.__internal__.serial.aux_connecting = "idle", new Promise((e, t) => {
-      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));
+      y() || t("Web Serial not supported"), this.#t || (this.#t = this.#a.bind(this)), this.on("internal:connecting", this.#t);
       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 }));
+        this.__internal__.serial.aux_connecting === "finished" ? (clearInterval(i), this.__internal__.serial.aux_connecting = "idle", this.#t !== null && this.off("internal:connecting", this.#t), 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();
     }));
@@ -350,9 +358,54 @@ class K extends I {
     } catch (e) {
       this.serialErrors(e);
     } finally {
-      this.__internal__.serial.reader = null, this.__internal__.serial.input_done = null, this.__internal__.serial.output_stream = null, this.__internal__.serial.output_done = null, this.__internal__.serial.connected = !1, this.__internal__.serial.port = null, c.$dispatchChange(this);
+      this.__internal__.serial.reader = null, this.__internal__.serial.input_done = null, this.__internal__.serial.output_stream = null, this.__internal__.serial.output_done = null, this.__internal__.serial.connected = !1, this.__internal__.serial.port = null, n.$dispatchChange(this);
     }
   }
+  async #r(e) {
+    const t = this.__internal__.serial.port;
+    if (!t || t && (!t.readable || !t.writable))
+      throw this.#s({ error: "Port is closed, not readable or writable." }), new Error("The port is closed or is not readable/writable");
+    const i = this.validateBytes(e);
+    if (this.useRTSCTS && await this.#l(t, 5e3), t.writable === null) return;
+    const s = t.writable.getWriter();
+    await s.write(i), s.releaseLock();
+  }
+  async #l(e, t = 5e3) {
+    const i = Date.now();
+    for (; ; ) {
+      if (Date.now() - i > t)
+        throw new Error("Timeout waiting for clearToSend signal");
+      const { clearToSend: s } = await e.getSignals();
+      if (s) return;
+      await f(100);
+    }
+  }
+  #e(e = new Uint8Array([]), t = !1) {
+    if (e && e.length > 0) {
+      const i = this.__internal__.serial.connected;
+      if (this.__internal__.serial.connected = this.#i(this.__internal__.serial.port), n.$dispatchChange(this), !i && this.__internal__.serial.connected && (this.dispatch("serial:connected"), this.#n(!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")
+        t ? this.serialCorruptMessage(this.parseUint8ToHex(e)) : this.serialMessage(this.parseUint8ToHex(e));
+      else if (this.__internal__.serial.response.as === "uint8")
+        t ? this.serialCorruptMessage(e) : this.serialMessage(e);
+      else if (this.__internal__.serial.response.as === "string") {
+        const s = this.parseUint8ArrayToString(e);
+        if (this.__internal__.serial.response.limiter !== null) {
+          const r = s.split(this.__internal__.serial.response.limiter);
+          for (const o in r)
+            r[o] && (t ? this.serialCorruptMessage(r[o]) : this.serialMessage(r[o]));
+        } else
+          t ? this.serialCorruptMessage(s) : this.serialMessage(s);
+      } else {
+        const s = this.stringToArrayBuffer(this.parseUint8ArrayToString(e));
+        t ? this.serialCorruptMessage(s) : this.serialMessage(s);
+      }
+    }
+    if (this.__internal__.serial.queue.length === 0) {
+      this.__internal__.serial.running_queue = !1;
+      return;
+    }
+    this.dispatch("internal:queue", {});
+  }
   getResponseAsArrayBuffer() {
     this.__internal__.serial.response.as = "arraybuffer";
   }
@@ -365,6 +418,13 @@ class K extends I {
   getResponseAsString() {
     this.__internal__.serial.response.as = "string";
   }
+  async #o() {
+    const e = this.serialFilters, t = await navigator.serial.getPorts({ filters: e });
+    return e.length === 0 ? t : t.filter((i) => {
+      const s = i.getInfo();
+      return e.some((r) => s.usbProductId === r.usbProductId && s.usbVendorId === r.usbVendorId);
+    }).filter((i) => !this.#i(i));
+  }
   async serialPortsSaved(e) {
     const t = this.serialFilters;
     if (this.__internal__.aux_port_connector < e.length) {
@@ -390,7 +450,7 @@ class K extends I {
       case t.includes(
         "this readable stream reader has been released and cannot be used to cancel its previous owner stream"
       ):
-        this.dispatch("serial:need-permission", {}), c.$dispatchChange(this);
+        this.dispatch("serial:need-permission", {}), n.$dispatchChange(this);
         break;
       case t.includes("the port is already open."):
       case t.includes("failed to open serial port"):
@@ -413,7 +473,7 @@ class K extends I {
       case t.includes("the port is already closed."):
         break;
       case t.includes("the device has been lost"):
-        this.dispatch("serial:lost", {}), c.$dispatchChange(this);
+        this.dispatch("serial:lost", {}), n.$dispatchChange(this);
         break;
       case t.includes("navigator.serial is undefined"):
         this.dispatch("serial:unsupported", {});
@@ -424,10 +484,108 @@ class K extends I {
     }
     this.dispatch("serial:error", e);
   }
+  #_(e) {
+    if (e) {
+      const t = this.__internal__.serial.response.buffer, i = new Uint8Array(t.length + e.byteLength);
+      i.set(t, 0), i.set(new Uint8Array(e), t.length), this.__internal__.serial.response.buffer = i;
+    }
+  }
+  async #c() {
+    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 && this.#e(this.__internal__.serial.response.buffer), this.__internal__.serial.response.buffer = new Uint8Array(0);
+    }, this.__internal__.serial.free_timeout_ms || 50);
+  }
+  async #h() {
+    const e = this.__internal__.serial.response.length;
+    let t = 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), !(e === null || !t || t.length === 0)) {
+      for (; t.length >= e; ) {
+        const i = t.slice(0, e);
+        this.#e(i), t = t.slice(e);
+      }
+      this.__internal__.serial.response.buffer = t, t.length > 0 && (this.__internal__.serial.time_until_send_bytes = setTimeout(() => {
+        this.#e(this.__internal__.serial.response.buffer, !0);
+      }, this.__internal__.serial.free_timeout_ms || 50));
+    }
+  }
+  async #u() {
+    const {
+      limiter: e,
+      prefixLimiter: t = !1,
+      sufixLimiter: i = !0
+    } = this.__internal__.serial.response;
+    if (!e)
+      throw new Error("No limiter defined for delimited serial response");
+    const s = this.__internal__.serial.response.buffer;
+    if (!e || !s || s.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 r = new TextDecoder().decode(s);
+    const o = [];
+    if (typeof e == "string") {
+      let a;
+      if (t && i)
+        a = new RegExp(`${e}([^${e}]+)${e}`, "g");
+      else if (t)
+        a = new RegExp(`${e}([^${e}]*)`, "g");
+      else if (i)
+        a = new RegExp(`([^${e}]+)${e}`, "g");
+      else
+        return;
+      let _, l = 0;
+      for (; (_ = a.exec(r)) !== null; )
+        o.push(new TextEncoder().encode(_[1])), l = a.lastIndex;
+      r = r.slice(l);
+    } else if (e instanceof RegExp) {
+      let a, _ = 0;
+      if (t && i) {
+        const l = new RegExp(`${e.source}(.*?)${e.source}`, "g");
+        for (; (a = l.exec(r)) !== null; )
+          o.push(new TextEncoder().encode(a[1])), _ = l.lastIndex;
+      } else if (i)
+        for (; (a = e.exec(r)) !== null; ) {
+          const l = a.index, h = r.slice(_, l);
+          o.push(new TextEncoder().encode(h)), _ = e.lastIndex;
+        }
+      else if (t) {
+        const l = r.split(e);
+        l.shift();
+        for (const h of l)
+          o.push(new TextEncoder().encode(h));
+        r = "";
+      }
+      r = r.slice(_);
+    }
+    for (const a of o)
+      this.#e(a);
+    const d = new TextEncoder().encode(r);
+    this.__internal__.serial.response.buffer = d, d.length > 0 && (this.__internal__.serial.time_until_send_bytes = setTimeout(() => {
+      this.#e(this.__internal__.serial.response.buffer, !0), this.__internal__.serial.response.buffer = new Uint8Array(0);
+    }, this.__internal__.serial.free_timeout_ms ?? 50));
+  }
+  async #d() {
+    const e = this.__internal__.serial.port;
+    if (!e || !e.readable) throw new Error("Port is not readable");
+    const t = e.readable.getReader();
+    this.__internal__.serial.reader = t;
+    try {
+      for (; this.__internal__.serial.keep_reading; ) {
+        const { value: i, done: s } = await t.read();
+        if (s) break;
+        this.#_(i), this.__internal__.serial.response.delimited ? await this.#u() : this.__internal__.serial.response.length === null ? await this.#c() : await this.#h();
+      }
+    } catch (i) {
+      this.serialErrors(i);
+    } finally {
+      t.releaseLock(), this.__internal__.serial.keep_reading = !0, this.__internal__.serial.port && await this.__internal__.serial.port.close();
+    }
+  }
+  #n(e) {
+    e !== this.__internal__.serial.connecting && (this.__internal__.serial.connecting = e, this.dispatch("serial:connecting", { active: e }), this.dispatch("internal:connecting", { active: e }));
+  }
   async serialConnect() {
     try {
-      l(this, r, g).call(this, !0);
-      const e = await l(this, r, N).call(this);
+      this.#n(!0);
+      const e = await this.#o();
       if (e.length > 0)
         await this.serialPortsSaved(e);
       else {
@@ -442,22 +600,24 @@ class K extends I {
       await t.open(this.serialConfigPort);
       const i = this;
       t.onconnect = (s) => {
-        var o;
-        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", {});
+        i.dispatch("serial:connected", s), i.#n(!1), n.$dispatchChange(this), i.__internal__.serial.queue.length > 0 ? i.dispatch("internal:queue", {}) : i.__internal__.serial.running_queue = !1;
       }, t.ondisconnect = async () => {
         await i.disconnect();
-      }, await M(this.__internal__.serial.delay_first_connection), this.__internal__.timeout.until_response = setTimeout(async () => {
+      }, await f(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", {
+      }, this.__internal__.time.response_connection), this.__internal__.serial.last_action = "connect", await this.#r(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, O).call(this);
+      }), this.__internal__.auto_response && this.#e(this.__internal__.serial.auto_response), await this.#d();
     } catch (e) {
-      l(this, r, g).call(this, !1), this.serialErrors(e);
+      this.#n(!1), this.serialErrors(e);
     }
   }
+  async #p() {
+    return typeof window > "u" ? !1 : "serial" in navigator && "forget" in SerialPort.prototype && this.__internal__.serial.port ? (await this.__internal__.serial.port.forget(), !0) : !1;
+  }
   async serialForget() {
-    return await l(this, r, H).call(this);
+    return await this.#p();
   }
   decToHex(e) {
     return typeof e == "string" && (e = parseInt(e, 10)), e.toString(16);
@@ -477,6 +637,70 @@ class K extends I {
   bytesToHex(e) {
     return this.add0x(Array.from(e, (t) => this.hexMaker(t)));
   }
+  #f() {
+    [
+      "serial:connected",
+      "serial:connecting",
+      "serial:reconnect",
+      "serial:timeout",
+      "serial:disconnected",
+      "serial:sent",
+      "serial:soft-reload",
+      "serial:message",
+      "serial:corrupt-message",
+      "unknown",
+      "serial:need-permission",
+      "serial:lost",
+      "serial:unsupported",
+      "serial:error",
+      "debug"
+    ].forEach((e) => {
+      this.serialRegisterAvailableListener(e);
+    });
+  }
+  #g() {
+    const e = this;
+    this.on("internal:queue", async () => {
+      await e.#b();
+    }), this.#y();
+  }
+  #y() {
+    const e = this;
+    navigator.serial.addEventListener("connect", async () => {
+      e.isDisconnected && await e.serialConnect().catch(() => {
+      });
+    });
+  }
+  async #b() {
+    if (!this.#i(this.__internal__.serial.port)) {
+      this.#s({ error: "Port is closed, not readable or writable." }), await this.serialConnect();
+      return;
+    }
+    if (this.__internal__.timeout.until_response) return;
+    if (this.__internal__.serial.queue.length === 0) {
+      this.__internal__.serial.running_queue = !1;
+      return;
+    }
+    this.__internal__.serial.running_queue = !0;
+    const e = this.__internal__.serial.queue[0];
+    let t = this.__internal__.time.response_general;
+    if (e.action === "connect" && (t = this.__internal__.time.response_connection), this.__internal__.timeout.until_response = setTimeout(async () => {
+      await this.timeout(e.bytes, e.action);
+    }, t), this.__internal__.serial.last_action = e.action ?? "unknown", await this.#r(e.bytes), this.dispatch("serial:sent", {
+      action: e.action,
+      bytes: e.bytes
+    }), this.__internal__.auto_response) {
+      let s = new Uint8Array(0);
+      try {
+        s = this.validateBytes(this.__internal__.serial.auto_response);
+      } catch (r) {
+        this.serialErrors(r);
+      }
+      this.#e(s);
+    }
+    const i = [...this.__internal__.serial.queue];
+    this.__internal__.serial.queue = i.splice(1), this.__internal__.serial.queue.length > 0 && (this.__internal__.serial.running_queue = !0);
+  }
   validateBytes(e) {
     let t = new Uint8Array(0);
     if (e instanceof Uint8Array)
@@ -500,6 +724,9 @@ class K extends I {
     }
     this.__internal__.serial.queue.push({ bytes: i, action: t }), this.dispatch("internal:queue", {});
   }
+  #m(e = 1) {
+    this.__internal__.device_number = e, !this.__internal__.bypassSerialBytesConnection && (this.__internal__.serial.bytes_connection = this.serialSetConnectionConstant(e));
+  }
   serialSetConnectionConstant(e = 1) {
     if (this.__internal__.bypassSerialBytesConnection) return this.__internal__.serial.bytes_connection;
     throw new Error(`Method not implemented 'serialSetConnectionConstant' to listen on channel ${e}`);
@@ -510,6 +737,14 @@ class K extends I {
   serialCorruptMessage(e) {
     throw console.log(e), this.dispatch("serial:corrupt-message", { code: e }), new Error("Method not implemented 'serialCorruptMessage'");
   }
+  #w() {
+    this.__internal__.last_error = {
+      message: null,
+      action: null,
+      code: null,
+      no_code: 0
+    };
+  }
   clearSerialQueue() {
     this.__internal__.serial.queue = [];
   }
@@ -529,7 +764,7 @@ class K extends I {
     });
   }
   softReload() {
-    l(this, r, Q).call(this), this.dispatch("serial:soft-reload", {});
+    this.#w(), this.dispatch("serial:soft-reload", {});
   }
   async sendConnect() {
     if (!this.__internal__.serial.bytes_connection)
@@ -587,8 +822,8 @@ class K extends I {
   asciiToHex(e) {
     const t = [];
     for (let i = 0, s = e.length; i < s; i++) {
-      const o = Number(e.charCodeAt(i)).toString(16);
-      t.push(o);
+      const r = Number(e.charCodeAt(i)).toString(16);
+      t.push(r);
     }
     return t.join("");
   }
@@ -596,217 +831,7 @@ class K extends I {
     return this.isConnected;
   }
 }
-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, 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: i } = await n.getSignals();
-    if (i) return;
-    await M(100);
-  }
-}, 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, 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(n) : this.serialMessage(n);
-    else if (this.__internal__.serial.response.as === "string") {
-      const i = this.parseUint8ArrayToString(n);
-      if (this.__internal__.serial.response.limiter !== null) {
-        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(i) : this.serialMessage(i);
-    } else {
-      const i = this.stringToArrayBuffer(this.parseUint8ArrayToString(n));
-      e ? this.serialCorruptMessage(i) : this.serialMessage(i);
-    }
-  }
-  this.__internal__.serial.queue.length !== 0 && this.dispatch("internal:queue", {});
-}, 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);
-}, 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), !(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));
-  }
-}, P = async function() {
-  const {
-    limiter: n,
-    prefixLimiter: e = !1,
-    sufixLimiter: t = !0
-  } = this.__internal__.serial.response;
-  if (!n)
-    throw new Error("No limiter defined for delimited serial response");
-  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(i);
-  const o = [];
-  if (typeof n == "string") {
-    let _;
-    if (e && t)
-      _ = new RegExp(`${n}([^${n}]+)${n}`, "g");
-    else if (e)
-      _ = new RegExp(`${n}([^${n}]*)`, "g");
-    else if (t)
-      _ = 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 (n instanceof RegExp) {
-    let _, d = 0;
-    if (e && t) {
-      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 (; (_ = 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(n);
-      h.shift();
-      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 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));
-}, 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: 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();
-  }
-}, 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;
-}, j = function() {
-  [
-    "serial:connected",
-    "serial:connecting",
-    "serial:reconnect",
-    "serial:timeout",
-    "serial:disconnected",
-    "serial:sent",
-    "serial:soft-reload",
-    "serial:message",
-    "serial:corrupt-message",
-    "unknown",
-    "serial:need-permission",
-    "serial:lost",
-    "serial:unsupported",
-    "serial:error",
-    "debug"
-  ].forEach((n) => {
-    this.serialRegisterAvailableListener(n);
-  });
-}, F = function() {
-  const n = this;
-  this.on("internal:queue", async () => {
-    var e;
-    await l(e = n, r, $).call(e);
-  }), l(this, r, U).call(this);
-}, U = function() {
-  const n = this;
-  navigator.serial.addEventListener("connect", async () => {
-    n.isDisconnected && await n.serialConnect().catch(() => {
-    });
-  });
-}, $ = 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 n = this.__internal__.serial.queue[0];
-  let e = this.__internal__.time.response_general;
-  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 i = new Uint8Array(0);
-    try {
-      i = this.validateBytes(this.__internal__.serial.auto_response);
-    } catch (s) {
-      this.serialErrors(s);
-    }
-    l(this, r, u).call(this, i);
-  }
-  const t = [...this.__internal__.serial.queue];
-  this.__internal__.serial.queue = t.splice(1);
-}, 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,
-    code: null,
-    no_code: 0
-  };
-};
 export {
-  K as Z,
-  c as h
+  b,
+  n as s
 };