@tbsoft-gmbh/signature-sdk 1.0.0

package/dist/hid-protocol.js

@@ -0,0 +1,2540 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// node_modules/node-gyp-build/node-gyp-build.js
+var require_node_gyp_build = __commonJS({
+  "node_modules/node-gyp-build/node-gyp-build.js"(exports2, module2) {
+    "use strict";
+    var fs = require("fs");
+    var path = require("path");
+    var os = require("os");
+    var runtimeRequire = typeof __webpack_require__ === "function" ? __non_webpack_require__ : require;
+    var vars = process.config && process.config.variables || {};
+    var prebuildsOnly = !!process.env.PREBUILDS_ONLY;
+    var abi = process.versions.modules;
+    var runtime = isElectron() ? "electron" : isNwjs() ? "node-webkit" : "node";
+    var arch = process.env.npm_config_arch || os.arch();
+    var platform = process.env.npm_config_platform || os.platform();
+    var libc = process.env.LIBC || (isAlpine(platform) ? "musl" : "glibc");
+    var armv = process.env.ARM_VERSION || (arch === "arm64" ? "8" : vars.arm_version) || "";
+    var uv = (process.versions.uv || "").split(".")[0];
+    module2.exports = load;
+    function load(dir) {
+      return runtimeRequire(load.resolve(dir));
+    }
+    load.resolve = load.path = function(dir) {
+      dir = path.resolve(dir || ".");
+      try {
+        var name = runtimeRequire(path.join(dir, "package.json")).name.toUpperCase().replace(/-/g, "_");
+        if (process.env[name + "_PREBUILD"]) dir = process.env[name + "_PREBUILD"];
+      } catch (err) {
+      }
+      if (!prebuildsOnly) {
+        var release = getFirst(path.join(dir, "build/Release"), matchBuild);
+        if (release) return release;
+        var debug = getFirst(path.join(dir, "build/Debug"), matchBuild);
+        if (debug) return debug;
+      }
+      var prebuild = resolve(dir);
+      if (prebuild) return prebuild;
+      var nearby = resolve(path.dirname(process.execPath));
+      if (nearby) return nearby;
+      var target = [
+        "platform=" + platform,
+        "arch=" + arch,
+        "runtime=" + runtime,
+        "abi=" + abi,
+        "uv=" + uv,
+        armv ? "armv=" + armv : "",
+        "libc=" + libc,
+        "node=" + process.versions.node,
+        process.versions.electron ? "electron=" + process.versions.electron : "",
+        typeof __webpack_require__ === "function" ? "webpack=true" : ""
+        // eslint-disable-line
+      ].filter(Boolean).join(" ");
+      throw new Error("No native build was found for " + target + "\n    loaded from: " + dir + "\n");
+      function resolve(dir2) {
+        var tuples = readdirSync(path.join(dir2, "prebuilds")).map(parseTuple);
+        var tuple = tuples.filter(matchTuple(platform, arch)).sort(compareTuples)[0];
+        if (!tuple) return;
+        var prebuilds = path.join(dir2, "prebuilds", tuple.name);
+        var parsed = readdirSync(prebuilds).map(parseTags);
+        var candidates = parsed.filter(matchTags(runtime, abi));
+        var winner = candidates.sort(compareTags(runtime))[0];
+        if (winner) return path.join(prebuilds, winner.file);
+      }
+    };
+    function readdirSync(dir) {
+      try {
+        return fs.readdirSync(dir);
+      } catch (err) {
+        return [];
+      }
+    }
+    function getFirst(dir, filter) {
+      var files = readdirSync(dir).filter(filter);
+      return files[0] && path.join(dir, files[0]);
+    }
+    function matchBuild(name) {
+      return /\.node$/.test(name);
+    }
+    function parseTuple(name) {
+      var arr = name.split("-");
+      if (arr.length !== 2) return;
+      var platform2 = arr[0];
+      var architectures = arr[1].split("+");
+      if (!platform2) return;
+      if (!architectures.length) return;
+      if (!architectures.every(Boolean)) return;
+      return { name, platform: platform2, architectures };
+    }
+    function matchTuple(platform2, arch2) {
+      return function(tuple) {
+        if (tuple == null) return false;
+        if (tuple.platform !== platform2) return false;
+        return tuple.architectures.includes(arch2);
+      };
+    }
+    function compareTuples(a, b) {
+      return a.architectures.length - b.architectures.length;
+    }
+    function parseTags(file) {
+      var arr = file.split(".");
+      var extension = arr.pop();
+      var tags = { file, specificity: 0 };
+      if (extension !== "node") return;
+      for (var i = 0; i < arr.length; i++) {
+        var tag = arr[i];
+        if (tag === "node" || tag === "electron" || tag === "node-webkit") {
+          tags.runtime = tag;
+        } else if (tag === "napi") {
+          tags.napi = true;
+        } else if (tag.slice(0, 3) === "abi") {
+          tags.abi = tag.slice(3);
+        } else if (tag.slice(0, 2) === "uv") {
+          tags.uv = tag.slice(2);
+        } else if (tag.slice(0, 4) === "armv") {
+          tags.armv = tag.slice(4);
+        } else if (tag === "glibc" || tag === "musl") {
+          tags.libc = tag;
+        } else {
+          continue;
+        }
+        tags.specificity++;
+      }
+      return tags;
+    }
+    function matchTags(runtime2, abi2) {
+      return function(tags) {
+        if (tags == null) return false;
+        if (tags.runtime && tags.runtime !== runtime2 && !runtimeAgnostic(tags)) return false;
+        if (tags.abi && tags.abi !== abi2 && !tags.napi) return false;
+        if (tags.uv && tags.uv !== uv) return false;
+        if (tags.armv && tags.armv !== armv) return false;
+        if (tags.libc && tags.libc !== libc) return false;
+        return true;
+      };
+    }
+    function runtimeAgnostic(tags) {
+      return tags.runtime === "node" && tags.napi;
+    }
+    function compareTags(runtime2) {
+      return function(a, b) {
+        if (a.runtime !== b.runtime) {
+          return a.runtime === runtime2 ? -1 : 1;
+        } else if (a.abi !== b.abi) {
+          return a.abi ? -1 : 1;
+        } else if (a.specificity !== b.specificity) {
+          return a.specificity > b.specificity ? -1 : 1;
+        } else {
+          return 0;
+        }
+      };
+    }
+    function isNwjs() {
+      return !!(process.versions && process.versions.nw);
+    }
+    function isElectron() {
+      if (process.versions && process.versions.electron) return true;
+      if (process.env.ELECTRON_RUN_AS_NODE) return true;
+      return typeof window !== "undefined" && window.process && window.process.type === "renderer";
+    }
+    function isAlpine(platform2) {
+      return platform2 === "linux" && fs.existsSync("/etc/alpine-release");
+    }
+    load.parseTags = parseTags;
+    load.matchTags = matchTags;
+    load.compareTags = compareTags;
+    load.parseTuple = parseTuple;
+    load.matchTuple = matchTuple;
+    load.compareTuples = compareTuples;
+  }
+});
+
+// node_modules/node-gyp-build/index.js
+var require_node_gyp_build2 = __commonJS({
+  "node_modules/node-gyp-build/index.js"(exports2, module2) {
+    "use strict";
+    var runtimeRequire = typeof __webpack_require__ === "function" ? __non_webpack_require__ : require;
+    if (typeof runtimeRequire.addon === "function") {
+      module2.exports = runtimeRequire.addon.bind(runtimeRequire);
+    } else {
+      module2.exports = require_node_gyp_build();
+    }
+  }
+});
+
+// node_modules/usb/dist/usb/bindings.js
+var require_bindings = __commonJS({
+  "node_modules/usb/dist/usb/bindings.js"(exports2, module2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    var path_1 = require("path");
+    var usb = require_node_gyp_build2()(process.env.NODE_USB_PATH || (0, path_1.join)(__dirname, "..", ".."));
+    module2.exports = usb;
+  }
+});
+
+// node_modules/usb/dist/usb/endpoint.js
+var require_endpoint = __commonJS({
+  "node_modules/usb/dist/usb/endpoint.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.OutEndpoint = exports2.InEndpoint = exports2.Endpoint = void 0;
+    var events_1 = require("events");
+    var bindings_1 = require_bindings();
+    var util_1 = require("util");
+    var isBuffer = (obj) => obj && obj instanceof Buffer;
+    var Endpoint = class extends events_1.EventEmitter {
+      constructor(device, descriptor) {
+        super();
+        this.device = device;
+        this.timeout = 0;
+        this.descriptor = descriptor;
+        this.address = descriptor.bEndpointAddress;
+        this.transferType = descriptor.bmAttributes & 3;
+      }
+      /** Clear the halt/stall condition for this endpoint. */
+      clearHalt(callback) {
+        return this.device.__clearHalt(this.address, callback);
+      }
+      /**
+       * Create a new `Transfer` object for this endpoint.
+       *
+       * The passed callback will be called when the transfer is submitted and finishes. Its arguments are the error (if any), the submitted buffer, and the amount of data actually written (for
+       * OUT transfers) or read (for IN transfers).
+       *
+       * @param timeout Timeout for the transfer (0 means unlimited).
+       * @param callback Transfer completion callback.
+       */
+      makeTransfer(timeout, callback) {
+        return new bindings_1.Transfer(this.device, this.address, this.transferType, timeout, callback);
+      }
+    };
+    exports2.Endpoint = Endpoint;
+    var InEndpoint = class extends Endpoint {
+      constructor(device, descriptor) {
+        super(device, descriptor);
+        this.direction = "in";
+        this.pollTransfers = [];
+        this.pollTransferSize = 0;
+        this.pollPending = 0;
+        this.pollActive = false;
+        this.transferAsync = (0, util_1.promisify)(this.transfer).bind(this);
+      }
+      /**
+       * Perform a transfer to read data from the endpoint.
+       *
+       * If length is greater than maxPacketSize, libusb will automatically split the transfer in multiple packets, and you will receive one callback with all data once all packets are complete.
+       *
+       * `this` in the callback is the InEndpoint object.
+       *
+       * The device must be open to use this method.
+       * @param length
+       * @param callback
+       */
+      transfer(length, callback) {
+        const buffer = Buffer.alloc(length);
+        const cb = (error, _buffer, actualLength) => {
+          callback.call(this, error, buffer.slice(0, actualLength));
+        };
+        try {
+          this.makeTransfer(this.timeout, cb).submit(buffer);
+        } catch (e) {
+          process.nextTick(() => callback.call(this, e));
+        }
+        return this;
+      }
+      /**
+       * Start polling the endpoint.
+       *
+       * The library will keep `nTransfers` transfers of size `transferSize` pending in the kernel at all times to ensure continuous data flow.
+       * This is handled by the libusb event thread, so it continues even if the Node v8 thread is busy. The `data` and `error` events are emitted as transfers complete.
+       *
+       * The device must be open to use this method.
+       * @param nTransfers
+       * @param transferSize
+       * @param callback
+       */
+      startPoll(nTransfers, transferSize, callback) {
+        const transferDone = (error, transfer, buffer, actualLength) => {
+          if (!error) {
+            this.emit("data", buffer.slice(0, actualLength));
+          } else if (error.errno !== bindings_1.LIBUSB_TRANSFER_CANCELLED) {
+            if (this.pollActive) {
+              this.emit("error", error);
+              this.stopPoll();
+            }
+          }
+          if (this.pollActive) {
+            startTransfer(transfer);
+          } else {
+            this.pollPending--;
+            if (this.pollPending === 0) {
+              this.pollTransfers = [];
+              this.pollActive = false;
+              this.emit("end");
+              if (callback) {
+                const cancelled = (error === null || error === void 0 ? void 0 : error.errno) === bindings_1.LIBUSB_TRANSFER_CANCELLED;
+                callback(cancelled ? void 0 : error, buffer, actualLength, cancelled);
+              }
+            }
+          }
+        };
+        const startTransfer = (transfer) => {
+          try {
+            transfer.submit(Buffer.alloc(this.pollTransferSize), (error, buffer, actualLength) => {
+              transferDone(error, transfer, buffer, actualLength);
+            });
+          } catch (e) {
+            this.emit("error", e);
+            this.stopPoll();
+          }
+        };
+        this.pollTransfers = this.startPollTransfers(nTransfers, transferSize, function(error, buffer, actualLength) {
+          transferDone(error, this, buffer, actualLength);
+        });
+        this.pollTransfers.forEach(startTransfer);
+        this.pollPending = this.pollTransfers.length;
+        return this.pollTransfers;
+      }
+      startPollTransfers(nTransfers = 3, transferSize = this.descriptor.wMaxPacketSize, callback) {
+        if (this.pollActive) {
+          throw new Error("Polling already active");
+        }
+        this.pollTransferSize = transferSize;
+        this.pollActive = true;
+        this.pollPending = 0;
+        const transfers = [];
+        for (let i = 0; i < nTransfers; i++) {
+          const transfer = this.makeTransfer(0, callback);
+          transfers[i] = transfer;
+        }
+        return transfers;
+      }
+      /**
+       * Stop polling.
+       *
+       * Further data may still be received. The `end` event is emitted and the callback is called once all transfers have completed or canceled.
+       *
+       * The device must be open to use this method.
+       * @param callback
+       */
+      stopPoll(callback) {
+        if (!this.pollActive) {
+          throw new Error("Polling is not active.");
+        }
+        for (let i = 0; i < this.pollTransfers.length; i++) {
+          try {
+            this.pollTransfers[i].cancel();
+          } catch (error) {
+            this.emit("error", error);
+          }
+        }
+        this.pollActive = false;
+        if (callback)
+          this.once("end", callback);
+      }
+    };
+    exports2.InEndpoint = InEndpoint;
+    var OutEndpoint = class extends Endpoint {
+      constructor(device, descriptor) {
+        super(device, descriptor);
+        this.direction = "out";
+        this.transferAsync = (0, util_1.promisify)(this.transfer).bind(this);
+      }
+      /**
+       * Perform a transfer to write `data` to the endpoint.
+       *
+       * If length is greater than maxPacketSize, libusb will automatically split the transfer in multiple packets, and you will receive one callback once all packets are complete.
+       *
+       * `this` in the callback is the OutEndpoint object.
+       *
+       * The device must be open to use this method.
+       * @param buffer
+       * @param callback
+       */
+      transfer(buffer, callback) {
+        if (!buffer) {
+          buffer = Buffer.alloc(0);
+        } else if (!isBuffer(buffer)) {
+          buffer = Buffer.from(buffer);
+        }
+        const cb = (error, _buffer, actual) => {
+          if (callback) {
+            callback.call(this, error, actual || 0);
+          }
+        };
+        try {
+          this.makeTransfer(this.timeout, cb).submit(buffer);
+        } catch (e) {
+          process.nextTick(() => cb(e));
+        }
+        return this;
+      }
+      transferWithZLP(buffer, callback) {
+        if (buffer.length % this.descriptor.wMaxPacketSize === 0) {
+          this.transfer(buffer);
+          this.transfer(Buffer.alloc(0), callback);
+        } else {
+          this.transfer(buffer, callback);
+        }
+      }
+    };
+    exports2.OutEndpoint = OutEndpoint;
+  }
+});
+
+// node_modules/usb/dist/usb/interface.js
+var require_interface = __commonJS({
+  "node_modules/usb/dist/usb/interface.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.Interface = void 0;
+    var bindings_1 = require_bindings();
+    var endpoint_1 = require_endpoint();
+    var util_1 = require("util");
+    var Interface = class {
+      constructor(device, id) {
+        this.device = device;
+        this.id = id;
+        this.altSetting = 0;
+        this.refresh();
+        this.releaseAsync = (0, util_1.promisify)(this.release).bind(this);
+        this.setAltSettingAsync = (0, util_1.promisify)(this.setAltSetting).bind(this);
+      }
+      refresh() {
+        if (!this.device.configDescriptor) {
+          return;
+        }
+        this.descriptor = this.device.configDescriptor.interfaces[this.id][this.altSetting];
+        this.interfaceNumber = this.descriptor.bInterfaceNumber;
+        this.endpoints = [];
+        const len = this.descriptor.endpoints.length;
+        for (let i = 0; i < len; i++) {
+          const desc = this.descriptor.endpoints[i];
+          const c = desc.bEndpointAddress & bindings_1.LIBUSB_ENDPOINT_IN ? endpoint_1.InEndpoint : endpoint_1.OutEndpoint;
+          this.endpoints[i] = new c(this.device, desc);
+        }
+      }
+      /**
+       * Claims the interface. This method must be called before using any endpoints of this interface.
+       *
+       * The device must be open to use this method.
+       */
+      claim() {
+        this.device.__claimInterface(this.id);
+      }
+      release(closeEndpointsOrCallback, callback) {
+        let closeEndpoints = false;
+        if (typeof closeEndpointsOrCallback === "boolean") {
+          closeEndpoints = closeEndpointsOrCallback;
+        } else {
+          callback = closeEndpointsOrCallback;
+        }
+        const next = () => {
+          this.device.__releaseInterface(this.id, (error) => {
+            if (!error) {
+              this.altSetting = 0;
+              this.refresh();
+            }
+            if (callback) {
+              callback.call(this, error);
+            }
+          });
+        };
+        if (!closeEndpoints || this.endpoints.length === 0) {
+          next();
+        } else {
+          let n = this.endpoints.length;
+          this.endpoints.forEach((ep) => {
+            if (ep.direction === "in" && ep.pollActive) {
+              ep.once("end", () => {
+                if (--n === 0) {
+                  next();
+                }
+              });
+              ep.stopPoll();
+            } else {
+              if (--n === 0) {
+                next();
+              }
+            }
+          });
+        }
+      }
+      /**
+       * Returns `false` if a kernel driver is not active; `true` if active.
+       *
+       * The device must be open to use this method.
+       */
+      isKernelDriverActive() {
+        return this.device.__isKernelDriverActive(this.id);
+      }
+      /**
+       * Detaches the kernel driver from the interface.
+       *
+       * The device must be open to use this method.
+       */
+      detachKernelDriver() {
+        return this.device.__detachKernelDriver(this.id);
+      }
+      /**
+       * Re-attaches the kernel driver for the interface.
+       *
+       * The device must be open to use this method.
+       */
+      attachKernelDriver() {
+        return this.device.__attachKernelDriver(this.id);
+      }
+      /**
+       * Sets the alternate setting. It updates the `interface.endpoints` array to reflect the endpoints found in the alternate setting.
+       *
+       * The device must be open to use this method.
+       * @param altSetting
+       * @param callback
+       */
+      setAltSetting(altSetting, callback) {
+        this.device.__setInterface(this.id, altSetting, (error) => {
+          if (!error) {
+            this.altSetting = altSetting;
+            this.refresh();
+          }
+          if (callback) {
+            callback.call(this, error);
+          }
+        });
+      }
+      /**
+       * Return the InEndpoint or OutEndpoint with the specified address.
+       *
+       * The device must be open to use this method.
+       * @param addr
+       */
+      endpoint(addr) {
+        return this.endpoints.find((item) => item.address === addr);
+      }
+    };
+    exports2.Interface = Interface;
+  }
+});
+
+// node_modules/usb/dist/usb/capability.js
+var require_capability = __commonJS({
+  "node_modules/usb/dist/usb/capability.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.Capability = void 0;
+    var Capability = class {
+      constructor(device, id) {
+        this.device = device;
+        this.id = id;
+        if (!device._bosDescriptor) {
+          throw new Error("bosDescriptor not found");
+        }
+        this.descriptor = device._bosDescriptor.capabilities[this.id];
+        this.type = this.descriptor.bDevCapabilityType;
+        this.data = this.descriptor.dev_capability_data;
+      }
+    };
+    exports2.Capability = Capability;
+  }
+});
+
+// node_modules/usb/dist/usb/device.js
+var require_device = __commonJS({
+  "node_modules/usb/dist/usb/device.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.ExtendedDevice = void 0;
+    var usb = require_bindings();
+    var interface_1 = require_interface();
+    var capability_1 = require_capability();
+    var isBuffer = (obj) => !!obj && obj instanceof Uint8Array;
+    var DEFAULT_TIMEOUT = 1e3;
+    var ExtendedDevice = class {
+      constructor() {
+        this._timeout = DEFAULT_TIMEOUT;
+      }
+      /**
+       * Timeout in milliseconds to use for control transfers.
+       */
+      get timeout() {
+        return this._timeout || DEFAULT_TIMEOUT;
+      }
+      set timeout(value) {
+        this._timeout = value;
+      }
+      /**
+       * Object with properties for the fields of the active configuration descriptor.
+       */
+      get configDescriptor() {
+        try {
+          return this.__getConfigDescriptor();
+        } catch (e) {
+          const errno = e.errno;
+          if (errno === usb.LIBUSB_ERROR_NOT_FOUND || errno === usb.LIBUSB_ERROR_NO_DEVICE) {
+            return void 0;
+          }
+          throw e;
+        }
+      }
+      /**
+       * Contains all config descriptors of the device (same structure as .configDescriptor above)
+       */
+      get allConfigDescriptors() {
+        try {
+          return this.__getAllConfigDescriptors();
+        } catch (e) {
+          const errno = e.errno;
+          if (errno === usb.LIBUSB_ERROR_NOT_FOUND || errno === usb.LIBUSB_ERROR_NO_DEVICE) {
+            return [];
+          }
+          throw e;
+        }
+      }
+      /**
+       * Contains the parent of the device, such as a hub. If there is no parent this property is set to `null`.
+       */
+      get parent() {
+        return this.__getParent();
+      }
+      /**
+       * Open the device.
+       * @param defaultConfig
+       */
+      open(defaultConfig = true) {
+        this.__open();
+        this.interfaces = [];
+        if (defaultConfig === false) {
+          return;
+        }
+        const len = this.configDescriptor ? this.configDescriptor.interfaces.length : 0;
+        for (let i = 0; i < len; i++) {
+          this.interfaces[i] = new interface_1.Interface(this, i);
+        }
+      }
+      /**
+       * Close the device.
+       *
+       * The device must be open to use this method.
+       */
+      close() {
+        this.__close();
+        this.interfaces = void 0;
+      }
+      /**
+       * Set the device configuration to something other than the default (0). To use this, first call `.open(false)` (which tells it not to auto configure),
+       * then before claiming an interface, call this method.
+       *
+       * The device must be open to use this method.
+       * @param desired
+       * @param callback
+       */
+      setConfiguration(desired, callback) {
+        this.__setConfiguration(desired, (error) => {
+          if (!error) {
+            this.interfaces = [];
+            const len = this.configDescriptor ? this.configDescriptor.interfaces.length : 0;
+            for (let i = 0; i < len; i++) {
+              this.interfaces[i] = new interface_1.Interface(this, i);
+            }
+          }
+          if (callback) {
+            callback.call(this, error);
+          }
+        });
+      }
+      /**
+       * Enable/disable libusb's automatic kernel driver detachment
+       * When this is enabled libusb will automatically detach the kernel driver on an interface when claiming the interface, and attach it when releasing the interface
+       *
+       * The device must be open to use this method.
+       */
+      setAutoDetachKernelDriver(enable) {
+        return this.__setAutoDetachKernelDriver(enable ? 1 : 0);
+      }
+      /**
+       * Perform a control transfer with `libusb_control_transfer`.
+       *
+       * Parameter `data_or_length` can be an integer length for an IN transfer, or a `Buffer` for an OUT transfer. The type must match the direction specified in the MSB of bmRequestType.
+       *
+       * The `data` parameter of the callback is actual transferred for OUT transfers, or will be passed a Buffer for IN transfers.
+       *
+       * The device must be open to use this method.
+       * @param bmRequestType
+       * @param bRequest
+       * @param wValue
+       * @param wIndex
+       * @param data_or_length
+       * @param callback
+       */
+      controlTransfer(bmRequestType, bRequest, wValue, wIndex, data_or_length, callback) {
+        const isIn = !!(bmRequestType & usb.LIBUSB_ENDPOINT_IN);
+        const wLength = isIn ? data_or_length : data_or_length.length;
+        if (isIn) {
+          if (wLength < 0) {
+            throw new TypeError("Expected size number for IN transfer (based on bmRequestType)");
+          }
+        } else {
+          if (!isBuffer(data_or_length)) {
+            throw new TypeError("Expected buffer for OUT transfer (based on bmRequestType)");
+          }
+        }
+        const buf = Buffer.alloc(wLength + usb.LIBUSB_CONTROL_SETUP_SIZE);
+        buf.writeUInt8(bmRequestType, 0);
+        buf.writeUInt8(bRequest, 1);
+        buf.writeUInt16LE(wValue, 2);
+        buf.writeUInt16LE(wIndex, 4);
+        buf.writeUInt16LE(wLength, 6);
+        if (!isIn) {
+          buf.set(data_or_length, usb.LIBUSB_CONTROL_SETUP_SIZE);
+        }
+        const transfer = new usb.Transfer(this, 0, usb.LIBUSB_TRANSFER_TYPE_CONTROL, this.timeout, (error, buf2, actual) => {
+          if (callback) {
+            if (isIn) {
+              callback.call(this, error, buf2.slice(usb.LIBUSB_CONTROL_SETUP_SIZE, usb.LIBUSB_CONTROL_SETUP_SIZE + actual));
+            } else {
+              callback.call(this, error, actual);
+            }
+          }
+        });
+        try {
+          transfer.submit(buf);
+        } catch (e) {
+          if (callback) {
+            process.nextTick(() => callback.call(this, e, void 0));
+          }
+        }
+        return this;
+      }
+      /**
+       * Return the interface with the specified interface number.
+       *
+       * The device must be open to use this method.
+       * @param addr
+       */
+      interface(addr) {
+        if (!this.interfaces) {
+          throw new Error("Device must be open before searching for interfaces");
+        }
+        addr = addr || 0;
+        for (let i = 0; i < this.interfaces.length; i++) {
+          if (this.interfaces[i].interfaceNumber === addr) {
+            return this.interfaces[i];
+          }
+        }
+        throw new Error(`Interface not found for address: ${addr}`);
+      }
+      /**
+       * Perform a control transfer to retrieve a string descriptor
+       *
+       * The device must be open to use this method.
+       * @param desc_index
+       * @param callback
+       */
+      getStringDescriptor(desc_index, callback) {
+        if (desc_index === 0) {
+          callback();
+          return;
+        }
+        const langid = 1033;
+        const length = 255;
+        this.controlTransfer(usb.LIBUSB_ENDPOINT_IN, usb.LIBUSB_REQUEST_GET_DESCRIPTOR, usb.LIBUSB_DT_STRING << 8 | desc_index, langid, length, (error, buffer) => {
+          if (error) {
+            return callback(error);
+          }
+          callback(void 0, isBuffer(buffer) ? buffer.toString("utf16le", 2) : void 0);
+        });
+      }
+      /**
+       * Perform a control transfer to retrieve an object with properties for the fields of the Binary Object Store descriptor.
+       *
+       * The device must be open to use this method.
+       * @param callback
+       */
+      getBosDescriptor(callback) {
+        if (this._bosDescriptor) {
+          return callback(void 0, this._bosDescriptor);
+        }
+        if (this.deviceDescriptor.bcdUSB < 513) {
+          return callback(void 0, void 0);
+        }
+        this.controlTransfer(usb.LIBUSB_ENDPOINT_IN, usb.LIBUSB_REQUEST_GET_DESCRIPTOR, usb.LIBUSB_DT_BOS << 8, 0, usb.LIBUSB_DT_BOS_SIZE, (error, buffer) => {
+          if (error) {
+            if (error.errno === usb.LIBUSB_TRANSFER_STALL)
+              return callback(void 0, void 0);
+            return callback(error, void 0);
+          }
+          if (!isBuffer(buffer)) {
+            return callback(void 0, void 0);
+          }
+          const totalLength = buffer.readUInt16LE(2);
+          this.controlTransfer(usb.LIBUSB_ENDPOINT_IN, usb.LIBUSB_REQUEST_GET_DESCRIPTOR, usb.LIBUSB_DT_BOS << 8, 0, totalLength, (error2, buffer2) => {
+            if (error2) {
+              if (error2.errno === usb.LIBUSB_TRANSFER_STALL)
+                return callback(void 0, void 0);
+              return callback(error2, void 0);
+            }
+            if (!isBuffer(buffer2)) {
+              return callback(void 0, void 0);
+            }
+            const descriptor = {
+              bLength: buffer2.readUInt8(0),
+              bDescriptorType: buffer2.readUInt8(1),
+              wTotalLength: buffer2.readUInt16LE(2),
+              bNumDeviceCaps: buffer2.readUInt8(4),
+              capabilities: []
+            };
+            let i = usb.LIBUSB_DT_BOS_SIZE;
+            while (i < descriptor.wTotalLength) {
+              const capability = {
+                bLength: buffer2.readUInt8(i + 0),
+                bDescriptorType: buffer2.readUInt8(i + 1),
+                bDevCapabilityType: buffer2.readUInt8(i + 2),
+                dev_capability_data: buffer2.slice(i + 3, i + buffer2.readUInt8(i + 0))
+              };
+              descriptor.capabilities.push(capability);
+              i += capability.bLength;
+            }
+            this._bosDescriptor = descriptor;
+            callback(void 0, this._bosDescriptor);
+          });
+        });
+      }
+      /**
+       * Retrieve a list of Capability objects for the Binary Object Store capabilities of the device.
+       *
+       * The device must be open to use this method.
+       * @param callback
+       */
+      getCapabilities(callback) {
+        const capabilities = [];
+        this.getBosDescriptor((error, descriptor) => {
+          if (error)
+            return callback(error, void 0);
+          const len = descriptor ? descriptor.capabilities.length : 0;
+          for (let i = 0; i < len; i++) {
+            capabilities.push(new capability_1.Capability(this, i));
+          }
+          callback(void 0, capabilities);
+        });
+      }
+    };
+    exports2.ExtendedDevice = ExtendedDevice;
+  }
+});
+
+// node_modules/usb/dist/usb/index.js
+var require_usb = __commonJS({
+  "node_modules/usb/dist/usb/index.js"(exports2, module2) {
+    "use strict";
+    var events_1 = require("events");
+    var device_1 = require_device();
+    var usb = require_bindings();
+    if (usb.INIT_ERROR) {
+      console.warn("Failed to initialize libusb.");
+    }
+    Object.setPrototypeOf(usb, events_1.EventEmitter.prototype);
+    Object.defineProperty(usb, "pollHotplug", {
+      value: false,
+      writable: true
+    });
+    Object.defineProperty(usb, "pollHotplugDelay", {
+      value: 500,
+      writable: true
+    });
+    if (usb.Device) {
+      Object.getOwnPropertyNames(device_1.ExtendedDevice.prototype).forEach((name) => {
+        Object.defineProperty(usb.Device.prototype, name, Object.getOwnPropertyDescriptor(device_1.ExtendedDevice.prototype, name) || /* @__PURE__ */ Object.create(null));
+      });
+    }
+    var hotPlugDevices = /* @__PURE__ */ new Set();
+    var emitHotplugEvents = () => {
+      const devices = new Set(usb.getDeviceList());
+      for (const device of devices) {
+        if (!hotPlugDevices.has(device)) {
+          usb.emit("attach", device);
+        }
+      }
+      for (const device of hotPlugDevices) {
+        if (!devices.has(device)) {
+          usb.emit("detach", device);
+        }
+      }
+      hotPlugDevices = devices;
+    };
+    var pollingHotplug = false;
+    var pollHotplug = (start = false) => {
+      if (start) {
+        pollingHotplug = true;
+      } else if (!pollingHotplug) {
+        return;
+      } else {
+        emitHotplugEvents();
+      }
+      setTimeout(() => pollHotplug(), usb.pollHotplugDelay);
+    };
+    var devicesChanged = () => setTimeout(() => emitHotplugEvents(), usb.pollHotplugDelay);
+    var hotplugSupported = 0;
+    var startHotplug = () => {
+      hotplugSupported = usb.pollHotplug ? 0 : usb._supportedHotplugEvents();
+      if (hotplugSupported !== 1) {
+        hotPlugDevices = new Set(usb.getDeviceList());
+      }
+      if (hotplugSupported) {
+        usb._enableHotplugEvents();
+        if (hotplugSupported === 2) {
+          usb.on("attachIds", devicesChanged);
+          usb.on("detachIds", devicesChanged);
+        }
+      } else {
+        pollHotplug(true);
+      }
+    };
+    var stopHotplug = () => {
+      if (hotplugSupported) {
+        usb._disableHotplugEvents();
+        if (hotplugSupported === 2) {
+          usb.off("attachIds", devicesChanged);
+          usb.off("detachIds", devicesChanged);
+        }
+      } else {
+        pollingHotplug = false;
+      }
+    };
+    usb.on("newListener", (event) => {
+      if (event !== "attach" && event !== "detach") {
+        return;
+      }
+      const listenerCount = usb.listenerCount("attach") + usb.listenerCount("detach");
+      if (listenerCount === 0) {
+        startHotplug();
+      }
+    });
+    usb.on("removeListener", (event) => {
+      if (event !== "attach" && event !== "detach") {
+        return;
+      }
+      const listenerCount = usb.listenerCount("attach") + usb.listenerCount("detach");
+      if (listenerCount === 0) {
+        stopHotplug();
+      }
+    });
+    module2.exports = usb;
+  }
+});
+
+// node_modules/usb/dist/webusb/webusb-device.js
+var require_webusb_device = __commonJS({
+  "node_modules/usb/dist/webusb/webusb-device.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.WebUSBDevice = void 0;
+    var usb = require_usb();
+    var util_1 = require("util");
+    var os_1 = require("os");
+    var LIBUSB_TRANSFER_TYPE_MASK = 3;
+    var ENDPOINT_NUMBER_MASK = 127;
+    var CLEAR_FEATURE = 1;
+    var ENDPOINT_HALT = 0;
+    var WebUSBDevice = class _WebUSBDevice {
+      static async createInstance(device, autoDetachKernelDriver = true) {
+        const instance = new _WebUSBDevice(device, autoDetachKernelDriver);
+        await instance.initialize();
+        return instance;
+      }
+      constructor(device, autoDetachKernelDriver) {
+        this.device = device;
+        this.autoDetachKernelDriver = autoDetachKernelDriver;
+        this.manufacturerName = null;
+        this.productName = null;
+        this.serialNumber = null;
+        this.configurations = [];
+        const usbVersion = this.decodeVersion(device.deviceDescriptor.bcdUSB);
+        this.usbVersionMajor = usbVersion.major;
+        this.usbVersionMinor = usbVersion.minor;
+        this.usbVersionSubminor = usbVersion.sub;
+        this.deviceClass = device.deviceDescriptor.bDeviceClass;
+        this.deviceSubclass = device.deviceDescriptor.bDeviceSubClass;
+        this.deviceProtocol = device.deviceDescriptor.bDeviceProtocol;
+        this.vendorId = device.deviceDescriptor.idVendor;
+        this.productId = device.deviceDescriptor.idProduct;
+        const deviceVersion = this.decodeVersion(device.deviceDescriptor.bcdDevice);
+        this.deviceVersionMajor = deviceVersion.major;
+        this.deviceVersionMinor = deviceVersion.minor;
+        this.deviceVersionSubminor = deviceVersion.sub;
+        this.controlTransferAsync = (0, util_1.promisify)(this.device.controlTransfer).bind(this.device);
+        this.setConfigurationAsync = (0, util_1.promisify)(this.device.setConfiguration).bind(this.device);
+        this.resetAsync = (0, util_1.promisify)(this.device.reset).bind(this.device);
+        this.getStringDescriptorAsync = (0, util_1.promisify)(this.device.getStringDescriptor).bind(this.device);
+      }
+      get configuration() {
+        if (!this.device.configDescriptor) {
+          return null;
+        }
+        const currentConfiguration = this.device.configDescriptor.bConfigurationValue;
+        return this.configurations.find((configuration) => configuration.configurationValue === currentConfiguration) || null;
+      }
+      get opened() {
+        return !!this.device.interfaces;
+      }
+      async open() {
+        try {
+          if (this.opened) {
+            return;
+          }
+          this.device.open();
+          if ((0, os_1.platform)() !== "win32") {
+            this.device.setAutoDetachKernelDriver(this.autoDetachKernelDriver);
+          }
+        } catch (error) {
+          throw new Error(`open error: ${error}`);
+        }
+      }
+      async close() {
+        try {
+          if (!this.opened) {
+            return;
+          }
+          try {
+            if (this.configuration) {
+              for (const iface of this.configuration.interfaces) {
+                await this._releaseInterface(iface.interfaceNumber);
+                this.configuration.interfaces[this.configuration.interfaces.indexOf(iface)] = {
+                  interfaceNumber: iface.interfaceNumber,
+                  alternate: iface.alternate,
+                  alternates: iface.alternates,
+                  claimed: false
+                };
+              }
+            }
+          } catch (_error) {
+          }
+          this.device.close();
+        } catch (error) {
+          throw new Error(`close error: ${error}`);
+        }
+      }
+      async selectConfiguration(configurationValue) {
+        if (!this.opened || !this.device.configDescriptor) {
+          throw new Error("selectConfiguration error: invalid state");
+        }
+        if (this.device.configDescriptor.bConfigurationValue === configurationValue) {
+          return;
+        }
+        const config = this.configurations.find((configuration) => configuration.configurationValue === configurationValue);
+        if (!config) {
+          throw new Error("selectConfiguration error: configuration not found");
+        }
+        try {
+          await this.setConfigurationAsync(configurationValue);
+        } catch (error) {
+          throw new Error(`selectConfiguration error: ${error}`);
+        }
+      }
+      async claimInterface(interfaceNumber) {
+        if (!this.opened) {
+          throw new Error("claimInterface error: invalid state");
+        }
+        if (!this.configuration) {
+          throw new Error("claimInterface error: interface not found");
+        }
+        const iface = this.configuration.interfaces.find((usbInterface) => usbInterface.interfaceNumber === interfaceNumber);
+        if (!iface) {
+          throw new Error("claimInterface error: interface not found");
+        }
+        if (iface.claimed) {
+          return;
+        }
+        try {
+          this.device.interface(interfaceNumber).claim();
+          this.configuration.interfaces[this.configuration.interfaces.indexOf(iface)] = {
+            interfaceNumber,
+            alternate: iface.alternate,
+            alternates: iface.alternates,
+            claimed: true
+          };
+        } catch (error) {
+          throw new Error(`claimInterface error: ${error}`);
+        }
+      }
+      async releaseInterface(interfaceNumber) {
+        await this._releaseInterface(interfaceNumber);
+        if (this.configuration) {
+          const iface = this.configuration.interfaces.find((usbInterface) => usbInterface.interfaceNumber === interfaceNumber);
+          if (iface) {
+            this.configuration.interfaces[this.configuration.interfaces.indexOf(iface)] = {
+              interfaceNumber,
+              alternate: iface.alternate,
+              alternates: iface.alternates,
+              claimed: false
+            };
+          }
+        }
+      }
+      async selectAlternateInterface(interfaceNumber, alternateSetting) {
+        if (!this.opened) {
+          throw new Error("selectAlternateInterface error: invalid state");
+        }
+        if (!this.configuration) {
+          throw new Error("selectAlternateInterface error: interface not found");
+        }
+        const iface = this.configuration.interfaces.find((usbInterface) => usbInterface.interfaceNumber === interfaceNumber);
+        if (!iface) {
+          throw new Error("selectAlternateInterface error: interface not found");
+        }
+        if (!iface.claimed) {
+          throw new Error("selectAlternateInterface error: invalid state");
+        }
+        try {
+          const iface2 = this.device.interface(interfaceNumber);
+          await iface2.setAltSettingAsync(alternateSetting);
+        } catch (error) {
+          throw new Error(`selectAlternateInterface error: ${error}`);
+        }
+      }
+      async controlTransferIn(setup, length) {
+        try {
+          this.checkDeviceOpen();
+          const type = this.controlTransferParamsToType(setup, usb.LIBUSB_ENDPOINT_IN);
+          const result = await this.controlTransferAsync(type, setup.request, setup.value, setup.index, length);
+          return {
+            data: result ? new DataView(new Uint8Array(result).buffer) : void 0,
+            status: "ok"
+          };
+        } catch (error) {
+          if (error.errno === usb.LIBUSB_TRANSFER_STALL) {
+            return {
+              status: "stall"
+            };
+          }
+          if (error.errno === usb.LIBUSB_TRANSFER_OVERFLOW) {
+            return {
+              status: "babble"
+            };
+          }
+          throw new Error(`controlTransferIn error: ${error}`);
+        }
+      }
+      async controlTransferOut(setup, data) {
+        try {
+          this.checkDeviceOpen();
+          const type = this.controlTransferParamsToType(setup, usb.LIBUSB_ENDPOINT_OUT);
+          const buffer = data ? Buffer.from(data) : Buffer.alloc(0);
+          const bytesWritten = await this.controlTransferAsync(type, setup.request, setup.value, setup.index, buffer);
+          return {
+            bytesWritten,
+            status: "ok"
+          };
+        } catch (error) {
+          if (error.errno === usb.LIBUSB_TRANSFER_STALL) {
+            return {
+              bytesWritten: 0,
+              status: "stall"
+            };
+          }
+          throw new Error(`controlTransferOut error: ${error}`);
+        }
+      }
+      async clearHalt(direction, endpointNumber) {
+        try {
+          const wIndex = endpointNumber | (direction === "in" ? usb.LIBUSB_ENDPOINT_IN : usb.LIBUSB_ENDPOINT_OUT);
+          await this.controlTransferAsync(usb.LIBUSB_RECIPIENT_ENDPOINT, CLEAR_FEATURE, ENDPOINT_HALT, wIndex, Buffer.from(new Uint8Array()));
+        } catch (error) {
+          throw new Error(`clearHalt error: ${error}`);
+        }
+      }
+      async transferIn(endpointNumber, length) {
+        try {
+          this.checkDeviceOpen();
+          const endpoint = this.getEndpoint(endpointNumber | usb.LIBUSB_ENDPOINT_IN);
+          const result = await endpoint.transferAsync(length);
+          return {
+            data: result ? new DataView(new Uint8Array(result).buffer) : void 0,
+            status: "ok"
+          };
+        } catch (error) {
+          if (error.errno === usb.LIBUSB_TRANSFER_STALL) {
+            return {
+              status: "stall"
+            };
+          }
+          if (error.errno === usb.LIBUSB_TRANSFER_OVERFLOW) {
+            return {
+              status: "babble"
+            };
+          }
+          throw new Error(`transferIn error: ${error}`);
+        }
+      }
+      async transferOut(endpointNumber, data) {
+        try {
+          this.checkDeviceOpen();
+          const endpoint = this.getEndpoint(endpointNumber | usb.LIBUSB_ENDPOINT_OUT);
+          const buffer = Buffer.from(data);
+          const bytesWritten = await endpoint.transferAsync(buffer);
+          return {
+            bytesWritten,
+            status: "ok"
+          };
+        } catch (error) {
+          if (error.errno === usb.LIBUSB_TRANSFER_STALL) {
+            return {
+              bytesWritten: 0,
+              status: "stall"
+            };
+          }
+          throw new Error(`transferOut error: ${error}`);
+        }
+      }
+      async reset() {
+        try {
+          await this.resetAsync();
+        } catch (error) {
+          throw new Error(`reset error: ${error}`);
+        }
+      }
+      async isochronousTransferIn(_endpointNumber, _packetLengths) {
+        throw new Error("isochronousTransferIn error: method not implemented");
+      }
+      async isochronousTransferOut(_endpointNumber, _data, _packetLengths) {
+        throw new Error("isochronousTransferOut error: method not implemented");
+      }
+      async forget() {
+        throw new Error("forget error: method not implemented");
+      }
+      async initialize() {
+        try {
+          if (!this.opened) {
+            this.device.open();
+            if (this.deviceClass === 255 && (0, os_1.platform)() === "darwin") {
+              await this.setConfigurationAsync(1);
+            }
+          }
+          this.manufacturerName = await this.getStringDescriptor(this.device.deviceDescriptor.iManufacturer);
+          this.productName = await this.getStringDescriptor(this.device.deviceDescriptor.iProduct);
+          this.serialNumber = await this.getStringDescriptor(this.device.deviceDescriptor.iSerialNumber);
+          this.configurations = await this.getConfigurations();
+        } catch (error) {
+          throw new Error(`initialize error: ${error}`);
+        } finally {
+          if (this.opened) {
+            this.device.close();
+          }
+        }
+      }
+      decodeVersion(version) {
+        const hex = `0000${version.toString(16)}`.slice(-4);
+        return {
+          major: parseInt(hex.substr(0, 2), void 0),
+          minor: parseInt(hex.substr(2, 1), void 0),
+          sub: parseInt(hex.substr(3, 1), void 0)
+        };
+      }
+      async getStringDescriptor(index) {
+        try {
+          const buffer = await this.getStringDescriptorAsync(index);
+          return buffer ? buffer.toString() : "";
+        } catch (error) {
+          return "";
+        }
+      }
+      async getConfigurations() {
+        const configs = [];
+        for (const config of this.device.allConfigDescriptors) {
+          const interfaces = [];
+          for (const iface of config.interfaces) {
+            const alternates = [];
+            for (const alternate2 of iface) {
+              const endpoints = [];
+              for (const endpoint of alternate2.endpoints) {
+                endpoints.push({
+                  endpointNumber: endpoint.bEndpointAddress & ENDPOINT_NUMBER_MASK,
+                  direction: endpoint.bEndpointAddress & usb.LIBUSB_ENDPOINT_IN ? "in" : "out",
+                  type: (endpoint.bmAttributes & LIBUSB_TRANSFER_TYPE_MASK) === usb.LIBUSB_TRANSFER_TYPE_BULK ? "bulk" : (endpoint.bmAttributes & LIBUSB_TRANSFER_TYPE_MASK) === usb.LIBUSB_TRANSFER_TYPE_INTERRUPT ? "interrupt" : "isochronous",
+                  packetSize: endpoint.wMaxPacketSize
+                });
+              }
+              alternates.push({
+                alternateSetting: alternate2.bAlternateSetting,
+                interfaceClass: alternate2.bInterfaceClass,
+                interfaceSubclass: alternate2.bInterfaceSubClass,
+                interfaceProtocol: alternate2.bInterfaceProtocol,
+                interfaceName: await this.getStringDescriptor(alternate2.iInterface),
+                endpoints
+              });
+            }
+            const interfaceNumber = iface[0].bInterfaceNumber;
+            const alternate = alternates.find((alt) => alt.alternateSetting === this.device.interface(interfaceNumber).altSetting);
+            if (alternate) {
+              interfaces.push({
+                interfaceNumber,
+                alternate,
+                alternates,
+                claimed: false
+              });
+            }
+          }
+          configs.push({
+            configurationValue: config.bConfigurationValue,
+            configurationName: await this.getStringDescriptor(config.iConfiguration),
+            interfaces
+          });
+        }
+        return configs;
+      }
+      getEndpoint(address) {
+        if (!this.device.interfaces) {
+          return void 0;
+        }
+        for (const iface of this.device.interfaces) {
+          const endpoint = iface.endpoint(address);
+          if (endpoint) {
+            return endpoint;
+          }
+        }
+        return void 0;
+      }
+      controlTransferParamsToType(setup, direction) {
+        const recipient = setup.recipient === "device" ? usb.LIBUSB_RECIPIENT_DEVICE : setup.recipient === "interface" ? usb.LIBUSB_RECIPIENT_INTERFACE : setup.recipient === "endpoint" ? usb.LIBUSB_RECIPIENT_ENDPOINT : usb.LIBUSB_RECIPIENT_OTHER;
+        const requestType = setup.requestType === "standard" ? usb.LIBUSB_REQUEST_TYPE_STANDARD : setup.requestType === "class" ? usb.LIBUSB_REQUEST_TYPE_CLASS : usb.LIBUSB_REQUEST_TYPE_VENDOR;
+        return recipient | requestType | direction;
+      }
+      async _releaseInterface(interfaceNumber) {
+        if (!this.opened) {
+          throw new Error("releaseInterface error: invalid state");
+        }
+        if (!this.configuration) {
+          throw new Error("releaseInterface error: interface not found");
+        }
+        const iface = this.configuration.interfaces.find((usbInterface) => usbInterface.interfaceNumber === interfaceNumber);
+        if (!iface) {
+          throw new Error("releaseInterface error: interface not found");
+        }
+        if (!iface.claimed) {
+          return;
+        }
+        try {
+          const iface2 = this.device.interface(interfaceNumber);
+          await iface2.releaseAsync();
+        } catch (error) {
+          throw new Error(`releaseInterface error: ${error}`);
+        }
+      }
+      checkDeviceOpen() {
+        if (!this.opened) {
+          throw new Error("The device must be opened first");
+        }
+      }
+    };
+    exports2.WebUSBDevice = WebUSBDevice;
+  }
+});
+
+// node_modules/usb/dist/webusb/index.js
+var require_webusb = __commonJS({
+  "node_modules/usb/dist/webusb/index.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.WebUSB = exports2.getWebUsb = void 0;
+    var usb = require_usb();
+    var events_1 = require("events");
+    var webusb_device_1 = require_webusb_device();
+    var getWebUsb = () => {
+      if (navigator && navigator.usb) {
+        return navigator.usb;
+      }
+      return new WebUSB();
+    };
+    exports2.getWebUsb = getWebUsb;
+    var NamedError = class extends Error {
+      constructor(message, name) {
+        super(message);
+        this.name = name;
+      }
+    };
+    var WebUSB = class {
+      constructor(options = {}) {
+        this.options = options;
+        this.emitter = new events_1.EventEmitter();
+        this.knownDevices = /* @__PURE__ */ new Map();
+        this.authorisedDevices = /* @__PURE__ */ new Set();
+        const deviceConnectCallback = async (device) => {
+          const webDevice = await this.getWebDevice(device);
+          if (webDevice && this.isAuthorisedDevice(webDevice)) {
+            const event = {
+              type: "connect",
+              device: webDevice
+            };
+            this.emitter.emit("connect", event);
+          }
+        };
+        const deviceDisconnectCallback = async (device) => {
+          if (this.knownDevices.has(device)) {
+            const webDevice = this.knownDevices.get(device);
+            if (webDevice && this.isAuthorisedDevice(webDevice)) {
+              const event = {
+                type: "disconnect",
+                device: webDevice
+              };
+              this.emitter.emit("disconnect", event);
+            }
+          }
+        };
+        this.emitter.on("newListener", (event) => {
+          const listenerCount = this.emitter.listenerCount(event);
+          if (listenerCount !== 0) {
+            return;
+          }
+          if (event === "connect") {
+            usb.addListener("attach", deviceConnectCallback);
+          } else if (event === "disconnect") {
+            usb.addListener("detach", deviceDisconnectCallback);
+          }
+        });
+        this.emitter.on("removeListener", (event) => {
+          const listenerCount = this.emitter.listenerCount(event);
+          if (listenerCount !== 0) {
+            return;
+          }
+          if (event === "connect") {
+            usb.removeListener("attach", deviceConnectCallback);
+          } else if (event === "disconnect") {
+            usb.removeListener("detach", deviceDisconnectCallback);
+          }
+        });
+      }
+      set onconnect(fn) {
+        if (this._onconnect) {
+          this.removeEventListener("connect", this._onconnect);
+          this._onconnect = void 0;
+        }
+        if (fn) {
+          this._onconnect = fn;
+          this.addEventListener("connect", this._onconnect);
+        }
+      }
+      set ondisconnect(fn) {
+        if (this._ondisconnect) {
+          this.removeEventListener("disconnect", this._ondisconnect);
+          this._ondisconnect = void 0;
+        }
+        if (fn) {
+          this._ondisconnect = fn;
+          this.addEventListener("disconnect", this._ondisconnect);
+        }
+      }
+      addEventListener(type, listener) {
+        this.emitter.addListener(type, listener);
+      }
+      removeEventListener(type, callback) {
+        this.emitter.removeListener(type, callback);
+      }
+      dispatchEvent(_event) {
+        return false;
+      }
+      /**
+       * Requests a single Web USB device
+       * @param options The options to use when scanning
+       * @returns Promise containing the selected device
+       */
+      async requestDevice(options) {
+        if (!options) {
+          throw new TypeError("requestDevice error: 1 argument required, but only 0 present");
+        }
+        if (options.constructor !== {}.constructor) {
+          throw new TypeError("requestDevice error: parameter 1 (options) is not an object");
+        }
+        if (!options.filters) {
+          throw new TypeError("requestDevice error: required member filters is undefined");
+        }
+        if (options.filters.constructor !== [].constructor) {
+          throw new TypeError("requestDevice error: the provided value cannot be converted to a sequence");
+        }
+        options.filters.forEach((filter) => {
+          if (filter.protocolCode && !filter.subclassCode) {
+            throw new TypeError("requestDevice error: subclass code is required");
+          }
+          if (filter.subclassCode && !filter.classCode) {
+            throw new TypeError("requestDevice error: class code is required");
+          }
+        });
+        let devices = await this.loadDevices(options.filters);
+        devices = devices.filter((device) => this.filterDevice(device, options.filters));
+        if (devices.length === 0) {
+          throw new NamedError("Failed to execute 'requestDevice' on 'USB': No device selected.", "NotFoundError");
+        }
+        try {
+          const device = this.options.devicesFound ? await this.options.devicesFound(devices) : devices[0];
+          if (!device) {
+            throw new NamedError("Failed to execute 'requestDevice' on 'USB': No device selected.", "NotFoundError");
+          }
+          this.authorisedDevices.add({
+            vendorId: device.vendorId,
+            productId: device.productId,
+            classCode: device.deviceClass,
+            subclassCode: device.deviceSubclass,
+            protocolCode: device.deviceProtocol,
+            serialNumber: device.serialNumber || void 0
+          });
+          return device;
+        } catch (error) {
+          throw new NamedError("Failed to execute 'requestDevice' on 'USB': No device selected.", "NotFoundError");
+        }
+      }
+      /**
+       * Gets all allowed Web USB devices which are connected
+       * @returns Promise containing an array of devices
+       */
+      async getDevices() {
+        const preFilters = this.options.allowAllDevices ? void 0 : this.options.allowedDevices;
+        const devices = await this.loadDevices(preFilters);
+        return devices.filter((device) => this.isAuthorisedDevice(device));
+      }
+      async loadDevices(preFilters) {
+        let devices = usb.getDeviceList();
+        devices = this.quickFilter(devices, preFilters);
+        const refreshedKnownDevices = /* @__PURE__ */ new Map();
+        for (const device of devices) {
+          const webDevice = await this.getWebDevice(device);
+          if (webDevice) {
+            refreshedKnownDevices.set(device, webDevice);
+          }
+        }
+        this.knownDevices = refreshedKnownDevices;
+        return [...this.knownDevices.values()];
+      }
+      // Get a WebUSBDevice corresponding to underlying device.
+      // Returns undefined the device was not found and could not be created.
+      async getWebDevice(device) {
+        if (!this.knownDevices.has(device)) {
+          if (this.options.deviceTimeout) {
+            device.timeout = this.options.deviceTimeout;
+          }
+          try {
+            const webDevice = await webusb_device_1.WebUSBDevice.createInstance(device, this.options.autoDetachKernelDriver);
+            this.knownDevices.set(device, webDevice);
+          } catch {
+          }
+        }
+        return this.knownDevices.get(device);
+      }
+      // Undertake quick filter on devices before creating WebUSB devices if possible
+      quickFilter(devices, preFilters) {
+        if (!preFilters || !preFilters.length) {
+          return devices;
+        }
+        return devices.filter((device) => preFilters.some((filter) => {
+          if (filter.vendorId && filter.vendorId !== device.deviceDescriptor.idVendor)
+            return false;
+          if (filter.productId && filter.productId !== device.deviceDescriptor.idProduct)
+            return false;
+          return true;
+        }));
+      }
+      // Filter WebUSB devices
+      filterDevice(device, filters) {
+        if (!filters || !filters.length) {
+          return true;
+        }
+        return filters.some((filter) => {
+          if (filter.vendorId && filter.vendorId !== device.vendorId)
+            return false;
+          if (filter.productId && filter.productId !== device.productId)
+            return false;
+          if (filter.classCode) {
+            if (!device.configuration) {
+              return false;
+            }
+            const match = device.configuration.interfaces.some((iface) => {
+              if (filter.classCode && filter.classCode !== iface.alternate.interfaceClass)
+                return false;
+              if (filter.subclassCode && filter.subclassCode !== iface.alternate.interfaceSubclass)
+                return false;
+              if (filter.protocolCode && filter.protocolCode !== iface.alternate.interfaceProtocol)
+                return false;
+              return true;
+            });
+            if (match) {
+              return true;
+            }
+          }
+          if (filter.classCode && filter.classCode !== device.deviceClass)
+            return false;
+          if (filter.subclassCode && filter.subclassCode !== device.deviceSubclass)
+            return false;
+          if (filter.protocolCode && filter.protocolCode !== device.deviceProtocol)
+            return false;
+          if (filter.serialNumber && filter.serialNumber !== device.serialNumber)
+            return false;
+          return true;
+        });
+      }
+      // Check whether a device is authorised
+      isAuthorisedDevice(device) {
+        if (this.options.allowAllDevices) {
+          return true;
+        }
+        if (this.options.allowedDevices && this.filterDevice(device, this.options.allowedDevices)) {
+          return true;
+        }
+        return [...this.authorisedDevices.values()].some((authorised) => authorised.vendorId === device.vendorId && authorised.productId === device.productId && authorised.classCode === device.deviceClass && authorised.subclassCode === device.deviceSubclass && authorised.protocolCode === device.deviceProtocol && authorised.serialNumber === device.serialNumber);
+      }
+    };
+    exports2.WebUSB = WebUSB;
+  }
+});
+
+// node_modules/usb/dist/usb/descriptors.js
+var require_descriptors = __commonJS({
+  "node_modules/usb/dist/usb/descriptors.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+  }
+});
+
+// node_modules/usb/dist/index.js
+var require_dist = __commonJS({
+  "node_modules/usb/dist/index.js"(exports2) {
+    "use strict";
+    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    } : function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    });
+    var __exportStar = exports2 && exports2.__exportStar || function(m, exports3) {
+      for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports3, p)) __createBinding(exports3, m, p);
+    };
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.LibUSBException = exports2.useUsbDkBackend = exports2.getDeviceList = exports2.Transfer = exports2.Device = exports2.webusb = exports2.findBySerialNumber = exports2.findByIds = exports2.usb = void 0;
+    var util_1 = require("util");
+    var webusb_1 = require_webusb();
+    var usb = require_usb();
+    exports2.usb = usb;
+    var findByIds = (vid, pid) => {
+      const devices = usb.getDeviceList();
+      return devices.find((item) => item.deviceDescriptor.idVendor === vid && item.deviceDescriptor.idProduct === pid);
+    };
+    exports2.findByIds = findByIds;
+    var findBySerialNumber = async (serialNumber) => {
+      const devices = usb.getDeviceList();
+      const opened = (device) => !!device.interfaces;
+      for (const device of devices) {
+        try {
+          if (!opened(device)) {
+            device.open();
+          }
+          const getStringDescriptor = (0, util_1.promisify)(device.getStringDescriptor).bind(device);
+          const buffer = await getStringDescriptor(device.deviceDescriptor.iSerialNumber);
+          if (buffer && buffer.toString() === serialNumber) {
+            return device;
+          }
+        } catch {
+        } finally {
+          try {
+            if (opened(device)) {
+              device.close();
+            }
+          } catch {
+          }
+        }
+      }
+      return void 0;
+    };
+    exports2.findBySerialNumber = findBySerialNumber;
+    var webusb = new webusb_1.WebUSB();
+    exports2.webusb = webusb;
+    var usb_1 = require_usb();
+    Object.defineProperty(exports2, "Device", { enumerable: true, get: function() {
+      return usb_1.Device;
+    } });
+    Object.defineProperty(exports2, "Transfer", { enumerable: true, get: function() {
+      return usb_1.Transfer;
+    } });
+    Object.defineProperty(exports2, "getDeviceList", { enumerable: true, get: function() {
+      return usb_1.getDeviceList;
+    } });
+    Object.defineProperty(exports2, "useUsbDkBackend", { enumerable: true, get: function() {
+      return usb_1.useUsbDkBackend;
+    } });
+    Object.defineProperty(exports2, "LibUSBException", { enumerable: true, get: function() {
+      return usb_1.LibUSBException;
+    } });
+    __exportStar(require_capability(), exports2);
+    __exportStar(require_descriptors(), exports2);
+    __exportStar(require_endpoint(), exports2);
+    __exportStar(require_interface(), exports2);
+    __exportStar(require_webusb(), exports2);
+    __exportStar(require_webusb_device(), exports2);
+  }
+});
+
+// src/hid-protocol.ts
+var hid_protocol_exports = {};
+__export(hid_protocol_exports, {
+  CMD: () => CMD,
+  HidProtocol: () => HidProtocol,
+  REG: () => REG,
+  RESP: () => RESP,
+  SIG_EVENT: () => SIG_EVENT
+});
+module.exports = __toCommonJS(hid_protocol_exports);
+
+// src/usb-transport.ts
+var import_events = require("events");
+var SIGNOTEC_VID = 8499;
+var SIGNOTEC_PID = 1;
+var REPORT_SIZE = 63;
+var UsbTransportDevice = class extends import_events.EventEmitter {
+  constructor(usbDevice, log) {
+    super();
+    this.usbDevice = null;
+    this.iface = null;
+    this.inEndpoint = null;
+    this.outEndpoint = null;
+    this.closed = false;
+    this.polling = false;
+    this.transferSize = REPORT_SIZE;
+    /**
+     * Write queue: each entry is a callback that starts the OUT transfer and
+     * calls `next()` when the transfer completes. This ensures the previous
+     * USB transfer is fully on the wire before the next one starts — matching
+     * node-hid's synchronous write() behavior.
+     */
+    this.writeQueue = [];
+    this.writeBusy = false;
+    /** Resolve callback for close() waiting on the write queue to drain. */
+    this.drainResolve = null;
+    this.usbDevice = usbDevice;
+    this.log = log;
+    try {
+      this.usbDevice.open();
+    } catch (err) {
+      throw new Error(`Cannot open USB device: ${err.message}`);
+    }
+    const { iface, inEp, outEp } = this.findEndpoints();
+    this.iface = iface;
+    this.inEndpoint = inEp;
+    this.outEndpoint = outEp;
+    this.transferSize = this.inEndpoint.descriptor?.wMaxPacketSize || REPORT_SIZE;
+    this.log.info?.(`USB endpoint max packet size: ${this.transferSize}`);
+    try {
+      if (this.iface.isKernelDriverActive?.()) {
+        this.iface.detachKernelDriver();
+      }
+    } catch {
+    }
+    try {
+      this.iface.claim();
+    } catch (err) {
+      this.usbDevice.close();
+      throw new Error(
+        `Cannot claim USB interface: ${err.message}. On Windows, you may need to install WinUSB driver using Zadig.`
+      );
+    }
+    this.startPolling();
+  }
+  findEndpoints() {
+    const interfaces = this.usbDevice.interfaces;
+    for (const iface of interfaces) {
+      let inEp = null;
+      let outEp = null;
+      for (const ep of iface.endpoints) {
+        if (ep.transferType === 3) {
+          if (ep.direction === "in") inEp = ep;
+          else if (ep.direction === "out") outEp = ep;
+        }
+      }
+      if (inEp && outEp) {
+        return { iface, inEp, outEp };
+      }
+    }
+    throw new Error(
+      "No suitable USB interface found with interrupt IN+OUT endpoints. The device may require a different driver."
+    );
+  }
+  startPolling() {
+    if (this.closed || !this.inEndpoint || this.polling) return;
+    this.polling = true;
+    this.inEndpoint.startPoll(3, this.transferSize);
+    this.inEndpoint.on("data", (data) => {
+      if (this.closed) return;
+      if (!data || data.length === 0) return;
+      this.emit("data", Buffer.from(data));
+    });
+    this.inEndpoint.on("error", (err) => {
+      if (this.closed) return;
+      if (err.message?.includes("LIBUSB_TRANSFER_CANCELLED")) return;
+      if (err.message?.includes("LIBUSB_TRANSFER_NO_DEVICE")) {
+        this.emit("error", new Error("Device disconnected"));
+        return;
+      }
+      this.log.error?.("USB IN error:", err.message);
+      this.emit("error", err);
+    });
+  }
+  /**
+   * Queue an OUT transfer. Transfers are serialized: each one completes
+   * before the next starts. This matches node-hid's synchronous write().
+   */
+  write(data) {
+    if (this.closed || !this.outEndpoint) {
+      throw new Error("Device not connected");
+    }
+    const buf = Buffer.alloc(REPORT_SIZE, 0);
+    for (let i = 0; i < Math.min(data.length, REPORT_SIZE); i++) {
+      buf[i] = data[i];
+    }
+    this.writeQueue.push(() => {
+      if (this.closed || !this.outEndpoint) {
+        queueMicrotask(() => this.drainNext());
+        return;
+      }
+      this.outEndpoint.transfer(buf, (err) => {
+        if (err && !this.closed) {
+          this.log.error("USB write error:", err.message);
+          this.emit("error", err);
+        }
+        this.drainNext();
+      });
+    });
+    if (!this.writeBusy) {
+      this.drainNext();
+    }
+  }
+  drainNext() {
+    const next = this.writeQueue.shift();
+    if (next) {
+      this.writeBusy = true;
+      next();
+    } else {
+      this.writeBusy = false;
+      this.drainResolve?.();
+      this.drainResolve = null;
+    }
+  }
+  /**
+   * Close the device. Waits up to 1s for any in-flight transfer to complete
+   * before releasing the USB interface.
+   */
+  close() {
+    if (this.closed) return;
+    this.closed = true;
+    this.writeQueue.length = 0;
+    const finish = () => {
+      if (this.polling && this.inEndpoint) {
+        try {
+          this.inEndpoint.removeAllListeners("data");
+          this.inEndpoint.removeAllListeners("error");
+          this.inEndpoint.stopPoll(() => this.releaseAndClose());
+        } catch {
+          this.releaseAndClose();
+        }
+      } else {
+        this.releaseAndClose();
+      }
+      this.polling = false;
+      this.removeAllListeners();
+    };
+    if (this.writeBusy) {
+      const timeout = setTimeout(() => {
+        this.log.warn("USB close: in-flight transfer did not complete in 1s, forcing close");
+        this.writeBusy = false;
+        finish();
+      }, 1e3);
+      new Promise((resolve) => {
+        this.drainResolve = resolve;
+      }).then(() => {
+        clearTimeout(timeout);
+        finish();
+      });
+    } else {
+      finish();
+    }
+  }
+  releaseAndClose() {
+    if (this.iface) {
+      try {
+        this.iface.release(true, () => {
+          try {
+            this.usbDevice?.close();
+          } catch {
+          }
+          this.usbDevice = null;
+        });
+      } catch {
+        try {
+          this.usbDevice?.close();
+        } catch {
+        }
+        this.usbDevice = null;
+      }
+    } else {
+      try {
+        this.usbDevice?.close();
+      } catch {
+      }
+      this.usbDevice = null;
+    }
+    this.inEndpoint = null;
+    this.outEndpoint = null;
+    this.iface = null;
+  }
+};
+function listUsbDevices(log) {
+  let usb;
+  try {
+    usb = require_dist();
+  } catch {
+    log.debug?.("usb package not available, skipping raw USB discovery");
+    return [];
+  }
+  try {
+    const deviceList = usb.getDeviceList();
+    const results = [];
+    for (const device of deviceList) {
+      const desc = device.deviceDescriptor;
+      if (desc.idVendor === SIGNOTEC_VID && desc.idProduct === SIGNOTEC_PID) {
+        results.push({
+          path: `usb:${desc.idVendor}:${desc.idProduct}:${device.busNumber}:${device.deviceAddress}`,
+          serialNumber: "",
+          product: "Signotec Pad",
+          _usbDevice: device
+        });
+      }
+    }
+    return results;
+  } catch (err) {
+    log.error?.("Failed to enumerate USB devices:", err.message);
+    return [];
+  }
+}
+function openUsbDevice(descriptor, log) {
+  return new UsbTransportDevice(descriptor._usbDevice, log);
+}
+
+// src/hid-protocol.ts
+var SIGNOTEC_VID2 = 8499;
+var SIGNOTEC_PID2 = 1;
+var HID_REPORT_SIZE = 63;
+var DEFAULTS = {
+  commandTimeout: 3e3,
+  imageTransferTimeout: 15e3,
+  flashStoreTimeout: 25e3,
+  chunkDelayMs: 2,
+  maxRetries: 2,
+  reconnectAttempts: 10,
+  reconnectIntervalMs: 2e3,
+  logger: console
+};
+var CMD = {
+  READ_REG: 1,
+  WRITE_REG: 16,
+  START_SIGN: 130,
+  STOP_SIGN: 131,
+  DRAW_IMAGE: 132,
+  IMAGE_DONE: 133,
+  ERASE_DISPLAY: 134,
+  STORE_IMAGE: 137,
+  SHOW_STORED: 138,
+  DATA_CHUNK: 96,
+  STORE_CHUNK: 112,
+  SLIDESHOW_CONFIG: 164,
+  EXTENDED: 168,
+  ADVANCED_BUTTON: 173
+};
+var BUTTON_CMD = {
+  CLEAR_ALL: 1,
+  SET_RECT: 4,
+  ENABLE_MONITORING: 10
+};
+var RESP = {
+  READ: 32,
+  ACK: 144,
+  START_ACK: 146,
+  STOP_ACK: 147,
+  IMAGE_ACK: 148,
+  ERROR: 224,
+  IDLE: 80
+};
+var REG = {
+  DEVICE_ID: 0,
+  FW_VERSION1: 1,
+  FW_VERSION2: 2,
+  STATE: 16,
+  CAPABILITIES: 17,
+  SERIAL: 20,
+  DISPLAY_WIDTH: 21,
+  DISPLAY_HEIGHT: 22,
+  SIGN_LEFT: 50,
+  SIGN_TOP: 51,
+  SIGN_RIGHT: 52,
+  SIGN_BOTTOM: 53
+};
+var SIG_EVENT = {
+  PEN_UP: 64,
+  PEN_DATA: 65,
+  PEN_DATA_EXT: 66,
+  HOTSPOT: 67
+};
+var HidProtocol = class {
+  constructor(config) {
+    this.device = null;
+    this.pending = null;
+    this.signatureCallback = null;
+    this.disconnectCallback = null;
+    this.connected = false;
+    this.closing = false;
+    /** Cached USB device descriptors from last listDevices() call (for USB fallback). */
+    this.usbDeviceMap = /* @__PURE__ */ new Map();
+    this.config = {
+      commandTimeout: config?.commandTimeout ?? DEFAULTS.commandTimeout,
+      imageTransferTimeout: config?.imageTransferTimeout ?? DEFAULTS.imageTransferTimeout,
+      flashStoreTimeout: config?.flashStoreTimeout ?? DEFAULTS.flashStoreTimeout,
+      chunkDelayMs: config?.chunkDelayMs ?? DEFAULTS.chunkDelayMs,
+      maxRetries: config?.maxRetries ?? DEFAULTS.maxRetries,
+      reconnectAttempts: config?.reconnectAttempts ?? DEFAULTS.reconnectAttempts,
+      reconnectIntervalMs: config?.reconnectIntervalMs ?? DEFAULTS.reconnectIntervalMs
+    };
+    this.log = config?.logger === null ? { info() {
+    }, warn() {
+    }, error() {
+    }, debug() {
+    } } : config?.logger ?? DEFAULTS.logger;
+    try {
+      this.HID = require("node-hid");
+    } catch {
+      throw new Error(
+        "node-hid is required for Signotec HID support. Install with: npm install node-hid"
+      );
+    }
+  }
+  // ─── Device Management ──────────────────────────────────────────────────────
+  /**
+   * Discover all connected Signotec pads.
+   * Tries node-hid first; falls back to raw USB enumeration (libusb) if no
+   * HID devices are found (e.g., Windows without HID class driver).
+   * @returns Array of device descriptors (never throws).
+   */
+  listDevices() {
+    this.usbDeviceMap.clear();
+    try {
+      const hidDevices = this.HID.devices().filter((d) => d.vendorId === SIGNOTEC_VID2 && d.productId === SIGNOTEC_PID2).map((d) => ({
+        path: d.path,
+        serialNumber: d.serialNumber || "",
+        product: d.product || "Signotec Pad"
+      }));
+      if (hidDevices.length > 0) {
+        this.log.info(`Found ${hidDevices.length} Signotec pad(s) via HID`);
+        return hidDevices;
+      }
+    } catch (err) {
+      this.log.warn("HID enumeration failed:", err.message);
+    }
+    this.log.info("No Signotec pads found via HID, trying raw USB...");
+    try {
+      const usbDevices = listUsbDevices(this.log);
+      if (usbDevices.length > 0) {
+        this.log.info(`Found ${usbDevices.length} Signotec pad(s) via raw USB`);
+        for (const d of usbDevices) {
+          this.usbDeviceMap.set(d.path, d);
+        }
+        return usbDevices.map((d) => ({
+          path: d.path,
+          serialNumber: d.serialNumber || "",
+          product: d.product || "Signotec Pad"
+        }));
+      }
+    } catch (err) {
+      this.log.warn("USB enumeration failed:", err.message);
+    }
+    this.logDiscoveryDiagnostics();
+    return [];
+  }
+  /** Log diagnostic info when no devices are found. */
+  logDiscoveryDiagnostics() {
+    try {
+      const allHid = this.HID.devices();
+      const signotecHid = allHid.filter((d) => d.vendorId === SIGNOTEC_VID2);
+      this.log.warn(
+        `No Signotec pads found. HID bus: ${allHid.length} devices total, ${signotecHid.length} matching VID=0x${SIGNOTEC_VID2.toString(16)}.`
+      );
+      if (signotecHid.length > 0) {
+        this.log.warn("Signotec HID entries (wrong PID?):", JSON.stringify(
+          signotecHid.map((d) => ({ pid: d.productId, usagePage: d.usagePage, product: d.product }))
+        ));
+      }
+    } catch {
+    }
+    const platform = process.platform;
+    if (platform === "linux") {
+      this.log.warn(
+        "Linux: ensure udev rules are installed. Copy 99-signotec.rules to /etc/udev/rules.d/ and run: sudo udevadm control --reload-rules && sudo udevadm trigger"
+      );
+    } else if (platform === "darwin") {
+      this.log.warn(
+        "macOS: check System Preferences > Security & Privacy > Input Monitoring permissions."
+      );
+    } else if (platform === "win32") {
+      this.log.warn(
+        "Windows: the device may need the WinUSB driver. Install it using Zadig (https://zadig.akeo.ie/) by selecting the Signotec device and choosing WinUSB."
+      );
+    }
+  }
+  /**
+   * Open a device by its path (HID path or USB path).
+   * USB paths start with "usb:" and use the raw USB transport fallback.
+   * @throws Error if the device cannot be opened.
+   */
+  open(devicePath) {
+    if (this.device) this.close();
+    this.closing = false;
+    const usbDescriptor = this.usbDeviceMap.get(devicePath);
+    if (usbDescriptor) {
+      this.log.info("Opening Signotec pad via raw USB transport");
+      this.device = openUsbDevice(usbDescriptor, this.log);
+    } else {
+      this.device = new this.HID.HID(devicePath);
+    }
+    this.connected = true;
+    this.device.on("data", (data) => this.handleData(Buffer.from(data)));
+    this.device.on("error", (err) => {
+      if (this.closing) return;
+      this.log.error("Signotec HID error:", err.message);
+      this.connected = false;
+      this.disconnectCallback?.();
+    });
+  }
+  /** Close the device connection and release resources. */
+  close() {
+    this.closing = true;
+    this.connected = false;
+    if (this.pending) {
+      clearTimeout(this.pending.timer);
+      this.pending.resolve(null);
+      this.pending = null;
+    }
+    if (this.device) {
+      try {
+        this.device.removeAllListeners?.();
+      } catch {
+      }
+      try {
+        this.device.close();
+      } catch (err) {
+        this.log.warn("Error closing HID device:", err.message);
+      }
+      this.device = null;
+    }
+    this.signatureCallback = null;
+  }
+  /** Check if the device connection is alive. */
+  isConnected() {
+    return this.connected && this.device !== null && !this.closing;
+  }
+  /**
+   * Verify the device is actually responsive (sends a register read and checks response).
+   * Useful after reconnection or before starting a session.
+   */
+  async isResponsive() {
+    if (!this.isConnected()) return false;
+    const resp = await this.readRegister(REG.STATE);
+    return resp !== null;
+  }
+  /** Register a callback for device disconnect events. */
+  onDisconnect(cb) {
+    this.disconnectCallback = cb;
+  }
+  /** Register a callback for signature/hotspot events from the device. */
+  onSignatureEvent(cb) {
+    this.signatureCallback = cb;
+  }
+  // ─── Core I/O ─────────────────────────────────────────────────────────────────
+  send(bytes) {
+    if (!this.device || !this.connected) throw new Error("Device not connected");
+    const buf = Buffer.alloc(HID_REPORT_SIZE, 0);
+    for (let i = 0; i < Math.min(bytes.length, HID_REPORT_SIZE); i++) {
+      buf[i] = bytes[i];
+    }
+    this.device.write([...buf]);
+  }
+  /**
+   * Send a command and wait for the response.
+   * @returns Response buffer, or null on timeout/error.
+   */
+  sendCommand(bytes, timeout) {
+    const t = timeout ?? this.config.commandTimeout;
+    if (!this.device || !this.connected) return Promise.resolve(null);
+    if (this.pending) {
+      clearTimeout(this.pending.timer);
+      this.pending.resolve(null);
+      this.pending = null;
+    }
+    return new Promise((resolve) => {
+      const timer = setTimeout(() => {
+        if (this.pending?.resolve === resolve) {
+          this.pending = null;
+          resolve(null);
+        }
+      }, t);
+      this.pending = { resolve, timer };
+      try {
+        this.send(bytes);
+      } catch {
+        clearTimeout(timer);
+        this.pending = null;
+        this.connected = false;
+        resolve(null);
+      }
+    });
+  }
+  /**
+   * Send a command with automatic retry on failure.
+   * @param bytes Command bytes to send
+   * @param validateFn Function to check if response is valid (defaults to non-null + non-error)
+   * @param timeout Timeout per attempt
+   * @param maxRetries Max retry count (from config if not specified)
+   */
+  async sendCommandWithRetry(bytes, validateFn, timeout, maxRetries) {
+    const retries = maxRetries ?? this.config.maxRetries;
+    const validate = validateFn ?? ((r) => r[0] !== RESP.ERROR);
+    for (let attempt = 0; attempt <= retries; attempt++) {
+      const resp = await this.sendCommand(bytes, timeout);
+      if (resp && validate(resp)) return resp;
+      if (attempt < retries) {
+        this.log.warn(`HID command 0x${bytes[0]?.toString(16)} failed (attempt ${attempt + 1}/${retries + 1}), retrying...`);
+        await new Promise((r) => setTimeout(r, 100 * (attempt + 1)));
+      }
+    }
+    return null;
+  }
+  /** Send raw bytes without waiting for a response (fire-and-forget). */
+  sendRaw(bytes) {
+    try {
+      this.send(bytes);
+    } catch {
+      this.connected = false;
+    }
+  }
+  /**
+   * Send a bulk data chunk for image transfers.
+   * @param cmdByte Command byte (0x60 for display, 0x70 for flash store)
+   * @param data Source buffer
+   * @param offset Starting offset in data
+   * @param maxPayload Max bytes per chunk (default 62)
+   */
+  sendChunk(cmdByte, data, offset, maxPayload = 62) {
+    const chunk = Buffer.alloc(HID_REPORT_SIZE, 0);
+    chunk[0] = cmdByte;
+    const toCopy = Math.min(maxPayload, data.length - offset);
+    data.copy(chunk, 1, offset, offset + toCopy);
+    try {
+      this.device?.write([...chunk]);
+    } catch {
+      this.connected = false;
+    }
+  }
+  handleData(buf) {
+    const type = buf[0];
+    if (type === RESP.IDLE || type === 81) return;
+    if (type === SIG_EVENT.PEN_DATA || type === SIG_EVENT.PEN_UP || type === SIG_EVENT.PEN_DATA_EXT || type === SIG_EVENT.HOTSPOT) {
+      this.signatureCallback?.(type, buf);
+      return;
+    }
+    if (this.pending) {
+      clearTimeout(this.pending.timer);
+      const p = this.pending;
+      this.pending = null;
+      p.resolve(buf);
+    }
+  }
+  // ─── Register Operations ──────────────────────────────────────────────────────
+  /** Read a device register. Returns the data portion or null on error/timeout. */
+  async readRegister(reg) {
+    const resp = await this.sendCommand([CMD.READ_REG, reg]);
+    if (resp && (resp[0] & 240) === 32) {
+      const len = resp[2];
+      return Buffer.from(resp.slice(3, 3 + len));
+    }
+    return null;
+  }
+  /** Write a 4-byte little-endian value to a register. */
+  async writeRegister(reg, value) {
+    const resp = await this.sendCommand([
+      CMD.WRITE_REG,
+      reg,
+      4,
+      value & 255,
+      value >> 8 & 255,
+      value >> 16 & 255,
+      value >> 24 & 255
+    ]);
+    if (!resp) return false;
+    return (resp[0] & 240) === 32 || (resp[0] & 240) === 144;
+  }
+  /** Read full device info from registers. */
+  async getDeviceInfo() {
+    const info = {
+      serialNo: "unknown",
+      displayWidth: 320,
+      displayHeight: 160,
+      sensorWidth: 320,
+      sensorHeight: 160,
+      deviceId: 0,
+      fwMajor: 0,
+      fwMinor: 0,
+      capabilities: 0
+    };
+    const serial = await this.readRegister(REG.SERIAL);
+    if (serial) info.serialNo = serial.toString("utf16le").replace(/[\0#]/g, "");
+    const devId = await this.readRegister(REG.DEVICE_ID);
+    if (devId?.length && devId.length >= 4) info.deviceId = devId.readUInt32LE(0);
+    const fw1 = await this.readRegister(REG.FW_VERSION1);
+    if (fw1?.length && fw1.length >= 4) {
+      info.fwMajor = fw1.readUInt16LE(0);
+      info.fwMinor = fw1.readUInt16LE(2);
+    }
+    const caps = await this.readRegister(REG.CAPABILITIES);
+    if (caps?.length && caps.length >= 4) info.capabilities = caps.readUInt32LE(0);
+    const dw = await this.readRegister(REG.DISPLAY_WIDTH);
+    if (dw?.length && dw.length >= 4) info.displayWidth = dw.readUInt32LE(0);
+    const dh = await this.readRegister(REG.DISPLAY_HEIGHT);
+    if (dh?.length && dh.length >= 4) info.displayHeight = dh.readUInt32LE(0);
+    return info;
+  }
+  // ─── Display Commands ─────────────────────────────────────────────────────────
+  /** Erase the pad display (clear to white). */
+  async eraseDisplay() {
+    const resp = await this.sendCommandWithRetry(
+      [CMD.ERASE_DISPLAY],
+      (r) => r[0] === RESP.ACK
+    );
+    return resp !== null;
+  }
+  /**
+   * Send monochrome 1bpp bitmap data to the pad display.
+   * Protocol: 0x84 header → 0x60 data chunks → 0x85 done.
+   * Automatically inverts polarity (pad uses 1=black, framebuffer uses 0=black).
+   */
+  async drawImage(x, y, width, height, bitmapData) {
+    const imgHeader = Buffer.alloc(25, 0);
+    imgHeader[0] = CMD.DRAW_IMAGE;
+    imgHeader.writeInt32LE(x, 1);
+    imgHeader.writeInt32LE(y, 5);
+    imgHeader.writeInt32LE(width, 9);
+    imgHeader.writeInt32LE(height, 13);
+    const resp = await this.sendCommandWithRetry(
+      [...imgHeader],
+      (r) => r[0] === RESP.ACK,
+      this.config.imageTransferTimeout
+    );
+    if (!resp) return false;
+    const invertedData = Buffer.alloc(bitmapData.length);
+    for (let i = 0; i < bitmapData.length; i++) {
+      invertedData[i] = bitmapData[i] ^ 255;
+    }
+    const chunkPayload = 62;
+    for (let offset = 0; offset < invertedData.length; offset += chunkPayload) {
+      this.sendChunk(CMD.DATA_CHUNK, invertedData, offset, chunkPayload);
+      if (offset % (chunkPayload * 10) === 0 && offset > 0) {
+        await new Promise((r) => setTimeout(r, this.config.chunkDelayMs));
+      }
+    }
+    const doneResp = await this.sendCommand([CMD.IMAGE_DONE], this.config.imageTransferTimeout);
+    return doneResp !== null && (doneResp[0] === RESP.IMAGE_ACK || doneResp[0] === RESP.ACK);
+  }
+  // ─── Flash Storage ────────────────────────────────────────────────────────────
+  /**
+   * Store a 1bpp bitmap to the pad's non-volatile flash as standby image.
+   * Persists across power cycles and USB disconnects.
+   *
+   * Protocol: 0x89 header → 0x70 data chunks → 0xA4 standby config.
+   * Flash uses direct polarity (opposite of display), auto-detected.
+   */
+  async storeStandbyImage(width, height, bitmapData) {
+    let ones = 0;
+    for (let i = 0; i < bitmapData.length; i++) {
+      for (let b = 0; b < 8; b++) {
+        if (bitmapData[i] & 1 << b) ones++;
+      }
+    }
+    const needsInvert = ones > bitmapData.length * 4;
+    const storeData = Buffer.alloc(bitmapData.length);
+    for (let i = 0; i < bitmapData.length; i++) {
+      storeData[i] = needsInvert ? bitmapData[i] ^ 255 : bitmapData[i];
+    }
+    const storeHeader = Buffer.alloc(33, 0);
+    storeHeader[0] = CMD.STORE_IMAGE;
+    storeHeader.writeInt32LE(0, 1);
+    storeHeader.writeInt32LE(0, 5);
+    storeHeader.writeInt32LE(width, 9);
+    storeHeader.writeInt32LE(height, 13);
+    storeHeader.writeInt32LE(0, 17);
+    storeHeader.writeInt32LE(1, 21);
+    storeHeader.writeInt32LE(1, 25);
+    storeHeader.writeInt32LE(0, 29);
+    const resp1 = await this.sendCommand([...storeHeader], this.config.flashStoreTimeout);
+    if (!resp1 || resp1[0] !== RESP.ACK) {
+      this.log.error("Flash store header rejected:", resp1 ? `0x${resp1[0].toString(16)}` : "timeout");
+      return false;
+    }
+    const chunkPayload = 62;
+    for (let offset = 0; offset < storeData.length; offset += chunkPayload) {
+      this.sendChunk(CMD.STORE_CHUNK, storeData, offset, chunkPayload);
+      if (offset % (chunkPayload * 20) === 0 && offset > 0) {
+        await new Promise((r) => setTimeout(r, this.config.chunkDelayMs * 3));
+      }
+    }
+    await new Promise((r) => setTimeout(r, 500));
+    return this.sendSlideshowConfig(2, 3, 100, 1);
+  }
+  /**
+   * Show the stored standby image from flash on the display.
+   * Command 0x8A = "draw stored image" (from APIClosePad → APIDrawStoredImage).
+   *
+   * Single HID command - no image data transfer. Works regardless of who
+   * stored the image (our library, Signotec SlideShow tool, etc.)
+   */
+  async showStandbyFromFlash() {
+    const cmd = Buffer.alloc(33, 0);
+    cmd[0] = CMD.SHOW_STORED;
+    const resp = await this.sendCommand([...cmd], this.config.imageTransferTimeout);
+    return resp !== null && (resp[0] === RESP.ACK || resp[0] === 152);
+  }
+  /**
+   * Send a slideshow/standby configuration command (0xA4).
+   * Automatically wraps in 0xA8 for Sigma pads (which don't support direct 0xA4).
+   */
+  async sendSlideshowConfig(action, mode, count, flag) {
+    const configCmd = Buffer.alloc(49, 0);
+    configCmd[0] = CMD.SLIDESHOW_CONFIG;
+    configCmd.writeInt32LE(action, 1);
+    configCmd.writeInt32LE(mode, 5);
+    configCmd.writeInt32LE(count, 9);
+    configCmd.writeInt32LE(flag, 13);
+    let resp = await this.sendCommand([...configCmd], 5e3);
+    if (!resp || resp[0] === RESP.ERROR) {
+      const a8cmd = Buffer.alloc(50, 0);
+      a8cmd[0] = CMD.EXTENDED;
+      configCmd.copy(a8cmd, 1, 0, 49);
+      resp = await this.sendCommand([...a8cmd], 5e3);
+    }
+    return resp !== null && (resp[0] === RESP.ACK || (resp[0] & 240) === 144);
+  }
+  // ─── Sensor / Hotspot Commands ────────────────────────────────────────────────
+  /** Set the signature capture rectangle (left, top, width, height → registers 0x32-0x35). */
+  async setSignRect(left, top, width, height) {
+    const r1 = await this.writeRegister(REG.SIGN_LEFT, Math.round(left));
+    const r2 = await this.writeRegister(REG.SIGN_TOP, Math.round(top));
+    const r3 = await this.writeRegister(REG.SIGN_RIGHT, Math.round(left + width));
+    const r4 = await this.writeRegister(REG.SIGN_BOTTOM, Math.round(top + height));
+    return r1 && r2 && r3 && r4;
+  }
+  /** Clear all hotspot areas. */
+  async clearHotSpots() {
+    const resp = await this.sendCommand([CMD.ADVANCED_BUTTON, BUTTON_CMD.CLEAR_ALL]);
+    return resp !== null && (resp[0] & 240) === 144;
+  }
+  /**
+   * Add a hotspot (touch-sensitive button area).
+   * @param index Hotspot index (0-based)
+   * @param left X position
+   * @param top Y position
+   * @param width Width in pixels
+   * @param height Height in pixels
+   */
+  async addHotSpot(index, left, top, width, height) {
+    const resp = await this.sendCommand([
+      CMD.ADVANCED_BUTTON,
+      BUTTON_CMD.SET_RECT,
+      1,
+      Math.round(index) & 127 | 128,
+      Math.round(left) & 255,
+      Math.round(left) >> 8 & 255,
+      Math.round(top) & 255,
+      Math.round(top) >> 8 & 255,
+      0,
+      Math.round(width) & 255,
+      Math.round(width) >> 8 & 255,
+      Math.round(height) & 255,
+      Math.round(height) >> 8 & 255
+    ]);
+    return resp !== null && (resp[0] & 240) === 144;
+  }
+  /** Enable hotspot monitoring (call after addHotSpot). */
+  async enableHotspotMonitoring() {
+    const resp = await this.sendCommand([CMD.ADVANCED_BUTTON, BUTTON_CMD.ENABLE_MONITORING]);
+    return resp !== null && (resp[0] & 240) === 144;
+  }
+  // ─── Signature Session ────────────────────────────────────────────────────────
+  /** Start signature capture. Protocol: [0x82, 0x00, 0x00, 0x00, 0x00]. */
+  async startSignature() {
+    const resp = await this.sendCommandWithRetry(
+      [CMD.START_SIGN, 0, 0, 0, 0],
+      (r) => r[0] === RESP.START_ACK
+    );
+    return resp !== null;
+  }
+  /** Stop signature capture. */
+  async stopSignature() {
+    const resp = await this.sendCommand([CMD.STOP_SIGN]);
+    return resp !== null && resp[0] === RESP.STOP_ACK;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CMD,
+  HidProtocol,
+  REG,
+  RESP,
+  SIG_EVENT
+});
+//# sourceMappingURL=hid-protocol.js.map