@tbsoft-gmbh/signature-sdk 1.0.0 → 1.0.2

package/dist/driver-hid.js

@@ -8,9 +8,6 @@ var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __esm = (fn, res) => function __init() {
   return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
 };
-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 });
@@ -33,1703 +30,6 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 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 fs3 = require("fs");
-    var path2 = 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 = path2.resolve(dir || ".");
-      try {
-        var name = runtimeRequire(path2.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(path2.join(dir, "build/Release"), matchBuild);
-        if (release) return release;
-        var debug = getFirst(path2.join(dir, "build/Debug"), matchBuild);
-        if (debug) return debug;
-      }
-      var prebuild = resolve(dir);
-      if (prebuild) return prebuild;
-      var nearby = resolve(path2.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(path2.join(dir2, "prebuilds")).map(parseTuple);
-        var tuple = tuples.filter(matchTuple(platform, arch)).sort(compareTuples)[0];
-        if (!tuple) return;
-        var prebuilds = path2.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 path2.join(prebuilds, winner.file);
-      }
-    };
-    function readdirSync(dir) {
-      try {
-        return fs3.readdirSync(dir);
-      } catch (err) {
-        return [];
-      }
-    }
-    function getFirst(dir, filter) {
-      var files = readdirSync(dir).filter(filter);
-      return files[0] && path2.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" && fs3.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/png-decode.ts
 var png_decode_exports = {};
 __export(png_decode_exports, {
@@ -2053,10 +353,10 @@ var UsbTransportDevice = class extends import_events.EventEmitter {
     this.iface = null;
   }
 };
-function listUsbDevices(log) {
+async function listUsbDevices(log) {
   let usb;
   try {
-    usb = require_dist();
+    usb = require("usb");
   } catch {
     log.debug?.("usb package not available, skipping raw USB discovery");
     return [];
@@ -2067,10 +367,34 @@ function listUsbDevices(log) {
     for (const device of deviceList) {
       const desc = device.deviceDescriptor;
       if (desc.idVendor === SIGNOTEC_VID && desc.idProduct === SIGNOTEC_PID) {
+        let serialNumber = "";
+        let product = "Signotec Pad";
+        if (desc.iSerialNumber || desc.iProduct) {
+          try {
+            device.open();
+            if (desc.iSerialNumber) {
+              serialNumber = await new Promise((resolve) => {
+                device.getStringDescriptor(desc.iSerialNumber, (err, val) => {
+                  resolve(err ? "" : (val || "").trim());
+                });
+              });
+            }
+            if (desc.iProduct) {
+              product = await new Promise((resolve) => {
+                device.getStringDescriptor(desc.iProduct, (err, val) => {
+                  resolve(err ? "Signotec Pad" : (val || "Signotec Pad").trim());
+                });
+              });
+            }
+            device.close();
+          } catch (err) {
+            log.debug?.("Could not read USB string descriptors:", err.message);
+          }
+        }
         results.push({
           path: `usb:${desc.idVendor}:${desc.idProduct}:${device.busNumber}:${device.deviceAddress}`,
-          serialNumber: "",
-          product: "Signotec Pad",
+          serialNumber,
+          product,
           _usbDevice: device
         });
       }
@@ -2188,7 +512,7 @@ var HidProtocol = class {
    * HID devices are found (e.g., Windows without HID class driver).
    * @returns Array of device descriptors (never throws).
    */
-  listDevices() {
+  async listDevices() {
     this.usbDeviceMap.clear();
     try {
       const hidDevices = this.HID.devices().filter((d) => d.vendorId === SIGNOTEC_VID2 && d.productId === SIGNOTEC_PID2).map((d) => ({
@@ -2205,7 +529,7 @@ var HidProtocol = class {
     }
     this.log.info("No Signotec pads found via HID, trying raw USB...");
     try {
-      const usbDevices = listUsbDevices(this.log);
+      const usbDevices = await listUsbDevices(this.log);
       if (usbDevices.length > 0) {
         this.log.info(`Found ${usbDevices.length} Signotec pad(s) via raw USB`);
         for (const d of usbDevices) {
@@ -3486,7 +1810,7 @@ function createHidDriver(config) {
     const maxAttempts = config?.reconnectAttempts ?? 10;
     const interval = config?.reconnectIntervalMs ?? 2e3;
     let attempts = 0;
-    const tryReconnect = () => {
+    const tryReconnect = async () => {
       attempts++;
       if (attempts > maxAttempts) {
         log.error(`Signotec pad reconnection failed after ${maxAttempts} attempts`);
@@ -3497,7 +1821,7 @@ function createHidDriver(config) {
       log.info(`Signotec reconnect attempt ${attempts}/${maxAttempts}...`);
       try {
         const prot = new HidProtocol(config);
-        const devices = prot.listDevices();
+        const devices = await prot.listDevices();
         if (devices.length > 0) {
           log.info("Signotec pad reconnected - cancelling session (state lost)");
           currentHandlers?.onUserEvent("cancel", { serialNo: currentSerialNo || "unknown" });
@@ -3561,7 +1885,7 @@ function createHidDriver(config) {
       await cleanup();
     }
     protocol = new HidProtocol(config);
-    const devices = protocol.listDevices();
+    const devices = await protocol.listDevices();
     if (devices.length === 0) {
       protocol = null;
       throw new Error(`No device with serialNo.: ${serialNo} was found.`);
@@ -3620,14 +1944,44 @@ function createHidDriver(config) {
     }
     emit("info", "Signing session started", "session", { serialNo: currentSerialNo });
   }
+  function emergencyClose() {
+    const prot = protocol;
+    if (!prot) return;
+    protocol = null;
+    try {
+      prot.close();
+    } catch {
+    }
+  }
+  let exitHandlersInstalled = false;
+  function installExitHandlers() {
+    if (exitHandlersInstalled) return;
+    exitHandlersInstalled = true;
+    process.on("exit", emergencyClose);
+    const gracefulExit = async (signal) => {
+      log.info(`Received ${signal}, closing Signotec device...`);
+      try {
+        await cleanup();
+      } catch {
+      }
+      process.removeListener(signal, gracefulExit);
+      process.kill(process.pid, signal);
+    };
+    process.on("SIGINT", gracefulExit);
+    process.on("SIGTERM", gracefulExit);
+    if (process.platform === "win32") {
+      process.on("SIGBREAK", gracefulExit);
+    }
+  }
+  installExitHandlers();
   const driver = {
-    getSignotecPads() {
+    async getSignotecPads() {
       if (cachedDeviceList && Date.now() - cacheTimestamp < CACHE_TTL) {
         return cachedDeviceList;
       }
       try {
         const prot = new HidProtocol(config);
-        const devices = prot.listDevices();
+        const devices = await prot.listDevices();
         cachedDeviceList = devices.map((d, i) => ({
           serialNo: d.serialNumber || `signotec-${i}`,
           type: 1,
@@ -3726,7 +2080,7 @@ function createHidDriver(config) {
       }
       try {
         const prot = new HidProtocol(config);
-        const devices = prot.listDevices();
+        const devices = await prot.listDevices();
         if (devices.length === 0) {
           log.error("No Signotec device connected for standby image upload");
           return false;
@@ -3761,7 +2115,7 @@ function createHidDriver(config) {
       const start = Date.now();
       const interval = 1e3;
       while (Date.now() - start < timeoutMs) {
-        const pads = driver.getSignotecPads();
+        const pads = await driver.getSignotecPads();
         if (pads.length > 0) return pads[0];
         await new Promise((r) => setTimeout(r, interval));
       }