usb 1.9.2 → 2.0.2

package/dist/index.d.ts

@@ -0,0 +1,17 @@
+import { WebUSB } from './webusb';
+import { WebUSBDevice } from './webusb/webusb-device';
+import * as usb from './usb';
+/**
+ * Convenience method to get the first device with the specified VID and PID, or `undefined` if no such device is present.
+ * @param vid
+ * @param pid
+ */
+declare const findByIds: (vid: number, pid: number) => usb.Device | undefined;
+/**
+ * Convenience method to get the device with the specified serial number, or `undefined` if no such device is present.
+ * @param serialNumber
+ */
+declare const findBySerialNumber: (serialNumber: string) => Promise<usb.Device | undefined>;
+declare const webusb: WebUSB;
+declare const getDeviceList: typeof usb.getDeviceList;
+export { usb, getDeviceList, findByIds, findBySerialNumber, webusb, WebUSB, WebUSBDevice };

package/dist/index.js

@@ -0,0 +1,138 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebUSBDevice = exports.WebUSB = exports.webusb = exports.findBySerialNumber = exports.findByIds = exports.getDeviceList = exports.usb = void 0;
+var util_1 = require("util");
+var webusb_1 = require("./webusb");
+Object.defineProperty(exports, "WebUSB", { enumerable: true, get: function () { return webusb_1.WebUSB; } });
+var webusb_device_1 = require("./webusb/webusb-device");
+Object.defineProperty(exports, "WebUSBDevice", { enumerable: true, get: function () { return webusb_device_1.WebUSBDevice; } });
+var usb = require("./usb");
+exports.usb = usb;
+/**
+ * Convenience method to get the first device with the specified VID and PID, or `undefined` if no such device is present.
+ * @param vid
+ * @param pid
+ */
+var findByIds = function (vid, pid) {
+    var devices = usb.getDeviceList();
+    return devices.find(function (item) { return item.deviceDescriptor.idVendor === vid && item.deviceDescriptor.idProduct === pid; });
+};
+exports.findByIds = findByIds;
+/**
+ * Convenience method to get the device with the specified serial number, or `undefined` if no such device is present.
+ * @param serialNumber
+ */
+var findBySerialNumber = function (serialNumber) { return __awaiter(void 0, void 0, void 0, function () {
+    var devices, opened, devices_1, devices_1_1, device, getStringDescriptor, buffer, _a, e_1_1;
+    var e_1, _b;
+    return __generator(this, function (_c) {
+        switch (_c.label) {
+            case 0:
+                devices = usb.getDeviceList();
+                opened = function (device) { return !!device.interfaces; };
+                _c.label = 1;
+            case 1:
+                _c.trys.push([1, 9, 10, 11]);
+                devices_1 = __values(devices), devices_1_1 = devices_1.next();
+                _c.label = 2;
+            case 2:
+                if (!!devices_1_1.done) return [3 /*break*/, 8];
+                device = devices_1_1.value;
+                _c.label = 3;
+            case 3:
+                _c.trys.push([3, 5, 6, 7]);
+                if (!opened(device)) {
+                    device.open();
+                }
+                getStringDescriptor = util_1.promisify(device.getStringDescriptor).bind(device);
+                return [4 /*yield*/, getStringDescriptor(device.deviceDescriptor.iSerialNumber)];
+            case 4:
+                buffer = _c.sent();
+                if (buffer && buffer.toString() === serialNumber) {
+                    return [2 /*return*/, device];
+                }
+                return [3 /*break*/, 7];
+            case 5:
+                _a = _c.sent();
+                return [3 /*break*/, 7];
+            case 6:
+                try {
+                    if (opened(device)) {
+                        device.close();
+                    }
+                }
+                catch (_d) {
+                    // Ignore any errors, device may be a system device or inaccessible
+                }
+                return [7 /*endfinally*/];
+            case 7:
+                devices_1_1 = devices_1.next();
+                return [3 /*break*/, 2];
+            case 8: return [3 /*break*/, 11];
+            case 9:
+                e_1_1 = _c.sent();
+                e_1 = { error: e_1_1 };
+                return [3 /*break*/, 11];
+            case 10:
+                try {
+                    if (devices_1_1 && !devices_1_1.done && (_b = devices_1.return)) _b.call(devices_1);
+                }
+                finally { if (e_1) throw e_1.error; }
+                return [7 /*endfinally*/];
+            case 11: return [2 /*return*/, undefined];
+        }
+    });
+}); };
+exports.findBySerialNumber = findBySerialNumber;
+var webusb = new webusb_1.WebUSB();
+exports.webusb = webusb;
+var getDeviceList = usb.getDeviceList;
+exports.getDeviceList = getDeviceList;
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../tsc/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,6BAAiC;AACjC,mCAAkC;AAkE9B,uFAlEK,eAAM,OAkEL;AAjEV,wDAAsD;AAoElD,6FApEK,4BAAY,OAoEL;AAnEhB,2BAA6B;AAqDzB,kBAAG;AAnDP;;;;GAIG;AACH,IAAM,SAAS,GAAG,UAAC,GAAW,EAAE,GAAW;IACvC,IAAM,OAAO,GAAG,GAAG,CAAC,aAAa,EAAE,CAAC;IACpC,OAAO,OAAO,CAAC,IAAI,CAAC,UAAA,IAAI,IAAI,OAAA,IAAI,CAAC,gBAAgB,CAAC,QAAQ,KAAK,GAAG,IAAI,IAAI,CAAC,gBAAgB,CAAC,SAAS,KAAK,GAAG,EAAjF,CAAiF,CAAC,CAAC;AACnH,CAAC,CAAC;AA+CE,8BAAS;AA7Cb;;;GAGG;AACH,IAAM,kBAAkB,GAAG,UAAO,YAAoB;;;;;;gBAC5C,OAAO,GAAG,GAAG,CAAC,aAAa,EAAE,CAAC;gBAC9B,MAAM,GAAG,UAAC,MAAkB,IAAc,OAAA,CAAC,CAAC,MAAM,CAAC,UAAU,EAAnB,CAAmB,CAAC;;;;gBAE/C,YAAA,SAAA,OAAO,CAAA;;;;gBAAjB,MAAM;;;;gBAET,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,EAAE;oBACjB,MAAM,CAAC,IAAI,EAAE,CAAC;iBACjB;gBAEK,mBAAmB,GAAG,gBAAS,CAAC,MAAM,CAAC,mBAAmB,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;gBAChE,qBAAM,mBAAmB,CAAC,MAAM,CAAC,gBAAgB,CAAC,aAAa,CAAC,EAAA;;gBAAzE,MAAM,GAAG,SAAgE;gBAE/E,IAAI,MAAM,IAAI,MAAM,CAAC,QAAQ,EAAE,KAAK,YAAY,EAAE;oBAC9C,sBAAO,MAAM,EAAC;iBACjB;;;;;;gBAID,IAAI;oBACA,IAAI,MAAM,CAAC,MAAM,CAAC,EAAE;wBAChB,MAAM,CAAC,KAAK,EAAE,CAAC;qBAClB;iBACJ;gBAAC,WAAM;oBACJ,mEAAmE;iBACtE;;;;;;;;;;;;;;;;qBAIT,sBAAO,SAAS,EAAC;;;KACpB,CAAC;AAYE,gDAAkB;AAVtB,IAAM,MAAM,GAAG,IAAI,eAAM,EAAE,CAAC;AAaxB,wBAAM;AAZV,IAAM,aAAa,GAAG,GAAG,CAAC,aAAa,CAAC;AAOpC,sCAAa"}

package/dist/usb/bindings.d.ts

@@ -0,0 +1,253 @@
+/// <reference types="node" />
+import type { DeviceDescriptor, ConfigDescriptor, BosDescriptor } from './descriptors';
+/**
+ * Return a list of `Device` objects for the USB devices attached to the system.
+ */
+export declare function getDeviceList(): Device[];
+export declare const INIT_ERROR: number;
+export declare class LibUSBException extends Error {
+    errno: number;
+}
+/**
+ * Set the libusb debug level (between 0 and 4)
+ * @param level libusb debug level (between 0 and 4)
+ */
+export declare function setDebugLevel(level: number): void;
+export declare function _enableHotplugEvents(): void;
+export declare function _disableHotplugEvents(): void;
+export declare function _getLibusbCapability(capability: number): number;
+/**
+ * Restore (re-reference) the hotplug events unreferenced by `unrefHotplugEvents()`
+ */
+export declare function refHotplugEvents(): void;
+/**
+ * Unreference the hotplug events from the event loop, allowing the process to exit even when listening for the `attach` and `detach` events
+ */
+export declare function unrefHotplugEvents(): void;
+/** Represents a USB transfer */
+export declare class Transfer {
+    constructor(device: Device, endpointAddr: number, type: number, timeout: number, callback: (error: LibUSBException, buf: Buffer, actual: number) => void);
+    /**
+     * (Re-)submit the transfer.
+     *
+     * @param buffer Buffer where data will be written (for IN transfers) or read from (for OUT transfers).
+     */
+    submit(buffer: Buffer, callback?: (error: LibUSBException | undefined, buffer: Buffer, actualLength: number) => void): Transfer;
+    /**
+     * Cancel the transfer.
+     *
+     * Returns `true` if the transfer was canceled, `false` if it wasn't in pending state.
+     */
+    cancel(): boolean;
+}
+/** Represents a USB device. */
+export declare class Device {
+    /** Integer USB device number */
+    busNumber: number;
+    /** Integer USB device address */
+    deviceAddress: number;
+    /** Array containing the USB device port numbers, or `undefined` if not supported on this platform. */
+    portNumbers: number[];
+    /** Object with properties for the fields of the device descriptor. */
+    deviceDescriptor: DeviceDescriptor;
+    _bosDescriptor?: BosDescriptor;
+    __open(): void;
+    __close(): void;
+    __getParent(): Device;
+    __getConfigDescriptor(): ConfigDescriptor;
+    __getAllConfigDescriptors(): ConfigDescriptor[];
+    __setConfiguration(desired: number, callback: (error?: LibUSBException) => void): void;
+    __clearHalt(addr: number, callback: (error?: LibUSBException) => void): void;
+    __setInterface(addr: number, altSetting: number, callback: (error?: LibUSBException) => void): void;
+    __claimInterface(addr: number): void;
+    __releaseInterface(addr: number, callback: (error?: LibUSBException) => void): void;
+    __detachKernelDriver(addr: number): void;
+    __attachKernelDriver(addr: number): void;
+    __isKernelDriverActive(addr: number): boolean;
+    /**
+    * Performs a reset of the device. Callback is called when complete.
+    *
+    * The device must be open to use this method.
+    * @param callback
+    */
+    reset(callback: (error?: LibUSBException) => void): void;
+}
+/**
+ * In the context of a \ref libusb_device_descriptor "device descriptor",
+ * this bDeviceClass value indicates that each interface specifies its
+ * own class information and all interfaces operate independently.
+ */
+export declare const LIBUSB_CLASS_PER_INTERFACE: number;
+/** Audio class */
+export declare const LIBUSB_CLASS_AUDIO: number;
+/** Communications class */
+export declare const LIBUSB_CLASS_COMM: number;
+/** Human Interface Device class */
+export declare const LIBUSB_CLASS_HID: number;
+/** Printer class */
+export declare const LIBUSB_CLASS_PRINTER: number;
+/** Image class */
+export declare const LIBUSB_CLASS_PTP: number;
+/** Mass storage class */
+export declare const LIBUSB_CLASS_MASS_STORAGE: number;
+/** Hub class */
+export declare const LIBUSB_CLASS_HUB: number;
+/** Data class */
+export declare const LIBUSB_CLASS_DATA: number;
+/** Wireless class */
+export declare const LIBUSB_CLASS_WIRELESS: number;
+/** Application class */
+export declare const LIBUSB_CLASS_APPLICATION: number;
+/** Class is vendor-specific */
+export declare const LIBUSB_CLASS_VENDOR_SPEC: number;
+/** Request status of the specific recipient */
+export declare const LIBUSB_REQUEST_GET_STATUS: number;
+/** Clear or disable a specific feature */
+export declare const LIBUSB_REQUEST_CLEAR_FEATURE: number;
+/** Set or enable a specific feature */
+export declare const LIBUSB_REQUEST_SET_FEATURE: number;
+/** Set device address for all future accesses */
+export declare const LIBUSB_REQUEST_SET_ADDRESS: number;
+/** Get the specified descriptor */
+export declare const LIBUSB_REQUEST_GET_DESCRIPTOR: number;
+/** Used to update existing descriptors or add new descriptors */
+export declare const LIBUSB_REQUEST_SET_DESCRIPTOR: number;
+/** Get the current device configuration value */
+export declare const LIBUSB_REQUEST_GET_CONFIGURATION: number;
+/** Set device configuration */
+export declare const LIBUSB_REQUEST_SET_CONFIGURATION: number;
+/** Return the selected alternate setting for the specified interface */
+export declare const LIBUSB_REQUEST_GET_INTERFACE: number;
+/** Select an alternate interface for the specified interface */
+export declare const LIBUSB_REQUEST_SET_INTERFACE: number;
+/** Set then report an endpoint's synchronization frame */
+export declare const LIBUSB_REQUEST_SYNCH_FRAME: number;
+/** Device descriptor. See libusb_device_descriptor. */
+export declare const LIBUSB_DT_DEVICE: number;
+/** Configuration descriptor. See libusb_config_descriptor. */
+export declare const LIBUSB_DT_CONFIG: number;
+/** String descriptor */
+export declare const LIBUSB_DT_STRING: number;
+export declare const LIBUSB_DT_BOS: number;
+/** Interface descriptor. See libusb_interface_descriptor. */
+export declare const LIBUSB_DT_INTERFACE: number;
+/** Endpoint descriptor. See libusb_endpoint_descriptor. */
+export declare const LIBUSB_DT_ENDPOINT: number;
+/** HID descriptor */
+export declare const LIBUSB_DT_HID: number;
+/** HID report descriptor */
+export declare const LIBUSB_DT_REPORT: number;
+/** Physical descriptor */
+export declare const LIBUSB_DT_PHYSICAL: number;
+/** Hub descriptor */
+export declare const LIBUSB_DT_HUB: number;
+/** In: device-to-host */
+export declare const LIBUSB_ENDPOINT_IN: number;
+/** Out: host-to-device */
+export declare const LIBUSB_ENDPOINT_OUT: number;
+/** Control endpoint */
+export declare const LIBUSB_TRANSFER_TYPE_CONTROL: number;
+/** Isochronous endpoint */
+export declare const LIBUSB_TRANSFER_TYPE_ISOCHRONOUS: number;
+/** Bulk endpoint */
+export declare const LIBUSB_TRANSFER_TYPE_BULK: number;
+/** Interrupt endpoint */
+export declare const LIBUSB_TRANSFER_TYPE_INTERRUPT: number;
+/** No synchronization */
+export declare const LIBUSB_ISO_SYNC_TYPE_NONE: number;
+/** Asynchronous */
+export declare const LIBUSB_ISO_SYNC_TYPE_ASYNC: number;
+/** Adaptive */
+export declare const LIBUSB_ISO_SYNC_TYPE_ADAPTIVE: number;
+/** Synchronous */
+export declare const LIBUSB_ISO_SYNC_TYPE_SYNC: number;
+/** Data endpoint */
+export declare const LIBUSB_ISO_USAGE_TYPE_DATA: number;
+/** Feedback endpoint */
+export declare const LIBUSB_ISO_USAGE_TYPE_FEEDBACK: number;
+/** Implicit feedback Data endpoint */
+export declare const LIBUSB_ISO_USAGE_TYPE_IMPLICIT: number;
+/**
+ * Transfer completed without error. Note that this does not indicate
+ * that the entire amount of requested data was transferred.
+ */
+export declare const LIBUSB_TRANSFER_COMPLETED: number;
+/** Transfer failed */
+export declare const LIBUSB_TRANSFER_ERROR: number;
+/** Transfer timed out */
+export declare const LIBUSB_TRANSFER_TIMED_OUT: number;
+/** Transfer was cancelled */
+export declare const LIBUSB_TRANSFER_CANCELLED: number;
+/**
+ * For bulk/interrupt endpoints: halt condition detected (endpoint
+ * stalled). For control endpoints: control request not supported.
+ */
+export declare const LIBUSB_TRANSFER_STALL: number;
+/** Device was disconnected */
+export declare const LIBUSB_TRANSFER_NO_DEVICE: number;
+/** Device sent more data than requested */
+export declare const LIBUSB_TRANSFER_OVERFLOW: number;
+/** Report short frames as errors */
+export declare const LIBUSB_TRANSFER_SHORT_NOT_OK: number;
+/**
+ * Automatically free() transfer buffer during libusb_free_transfer().
+ * Note that buffers allocated with libusb_dev_mem_alloc() should not
+ * be attempted freed in this way, since free() is not an appropriate
+ * way to release such memory.
+ */
+export declare const LIBUSB_TRANSFER_FREE_BUFFER: number;
+/**
+ * Automatically call libusb_free_transfer() after callback returns.
+ * If this flag is set, it is illegal to call libusb_free_transfer()
+ * from your transfer callback, as this will result in a double-free
+ * when this flag is acted upon.
+ */
+export declare const LIBUSB_TRANSFER_FREE_TRANSFER: number;
+/** Standard */
+export declare const LIBUSB_REQUEST_TYPE_STANDARD: number;
+/** Class */
+export declare const LIBUSB_REQUEST_TYPE_CLASS: number;
+/** Vendor */
+export declare const LIBUSB_REQUEST_TYPE_VENDOR: number;
+/** Reserved */
+export declare const LIBUSB_REQUEST_TYPE_RESERVED: number;
+/** Device */
+export declare const LIBUSB_RECIPIENT_DEVICE: number;
+/** Interface */
+export declare const LIBUSB_RECIPIENT_INTERFACE: number;
+/** Endpoint */
+export declare const LIBUSB_RECIPIENT_ENDPOINT: number;
+/** Other */
+export declare const LIBUSB_RECIPIENT_OTHER: number;
+export declare const LIBUSB_CONTROL_SETUP_SIZE: number;
+export declare const LIBUSB_DT_BOS_SIZE: number;
+export declare const LIBUSB_CAP_HAS_CAPABILITY: number;
+export declare const LIBUSB_CAP_HAS_HOTPLUG: number;
+export declare const LIBUSB_CAP_HAS_HID_ACCESS: number;
+export declare const LIBUSB_CAP_SUPPORTS_DETACH_KERNEL_DRIVER: number;
+/** Input/output error */
+export declare const LIBUSB_ERROR_IO: number;
+/** Invalid parameter */
+export declare const LIBUSB_ERROR_INVALID_PARAM: number;
+/** Access denied (insufficient permissions) */
+export declare const LIBUSB_ERROR_ACCESS: number;
+/** No such device (it may have been disconnected) */
+export declare const LIBUSB_ERROR_NO_DEVICE: number;
+/** Entity not found */
+export declare const LIBUSB_ERROR_NOT_FOUND: number;
+/** Resource busy */
+export declare const LIBUSB_ERROR_BUSY: number;
+/** Operation timed out */
+export declare const LIBUSB_ERROR_TIMEOUT: number;
+/** Overflow */
+export declare const LIBUSB_ERROR_OVERFLOW: number;
+/** Pipe error */
+export declare const LIBUSB_ERROR_PIPE: number;
+/** System call interrupted (perhaps due to signal) */
+export declare const LIBUSB_ERROR_INTERRUPTED: number;
+/** Insufficient memory */
+export declare const LIBUSB_ERROR_NO_MEM: number;
+/** Operation not supported or unimplemented on this platform */
+export declare const LIBUSB_ERROR_NOT_SUPPORTED: number;
+/** Other error */
+export declare const LIBUSB_ERROR_OTHER: number;

package/dist/usb/bindings.js

@@ -0,0 +1,10 @@
+"use strict";
+// Definitions from DefinitelyTyped, thanks to:
+//  Eric Brody <https://github.com/underscorebrody>
+//  Rob Moran <https://github.com/thegecko>
+Object.defineProperty(exports, "__esModule", { value: true });
+var path_1 = require("path");
+/* eslint-disable @typescript-eslint/no-var-requires */
+var usb = require('node-gyp-build')(path_1.join(__dirname, '..', '..'));
+module.exports = usb;
+//# sourceMappingURL=bindings.js.map

package/dist/usb/bindings.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bindings.js","sourceRoot":"","sources":["../../tsc/usb/bindings.ts"],"names":[],"mappings":";AAAA,+CAA+C;AAC/C,mDAAmD;AACnD,2CAA2C;;AAE3C,6BAA4B;AAG5B,uDAAuD;AACvD,IAAM,GAAG,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAAC,WAAI,CAAC,SAAS,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC,CAAC;AACnE,MAAM,CAAC,OAAO,GAAG,GAAG,CAAC"}

package/dist/usb/capability.d.ts

@@ -0,0 +1,14 @@
+/// <reference types="node" />
+import type { Device } from './bindings';
+import { CapabilityDescriptor } from './descriptors';
+export declare class Capability {
+    protected device: Device;
+    protected id: number;
+    /** Object with fields from the capability descriptor -- see libusb documentation or USB spec. */
+    descriptor: CapabilityDescriptor;
+    /** Integer capability type. */
+    type: number;
+    /** Buffer capability data. */
+    data: Buffer;
+    constructor(device: Device, id: number);
+}

package/dist/usb/capability.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Capability = void 0;
+var Capability = /** @class */ (function () {
+    function Capability(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;
+    }
+    return Capability;
+}());
+exports.Capability = Capability;
+//# sourceMappingURL=capability.js.map

package/dist/usb/capability.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"capability.js","sourceRoot":"","sources":["../../tsc/usb/capability.ts"],"names":[],"mappings":";;;AAGA;IAUI,oBAAsB,MAAc,EAAY,EAAU;QAApC,WAAM,GAAN,MAAM,CAAQ;QAAY,OAAE,GAAF,EAAE,CAAQ;QACtD,IAAI,CAAC,MAAM,CAAC,cAAc,EAAE;YACxB,MAAM,IAAI,KAAK,CAAC,yBAAyB,CAAC,CAAC;SAC9C;QACD,IAAI,CAAC,UAAU,GAAG,MAAM,CAAC,cAAc,CAAC,YAAY,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;QAC9D,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC,UAAU,CAAC,kBAAkB,CAAC;QAC/C,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC,UAAU,CAAC,mBAAmB,CAAC;IACpD,CAAC;IACL,iBAAC;AAAD,CAAC,AAlBD,IAkBC;AAlBY,gCAAU"}

package/dist/usb/descriptors.d.ts

@@ -0,0 +1,129 @@
+/// <reference types="node" />
+/** A structure representing the standard USB device descriptor */
+export interface DeviceDescriptor {
+    /** Size of this descriptor (in bytes) */
+    bLength: number;
+    /** Descriptor type. */
+    bDescriptorType: number;
+    /** USB specification release number in binary-coded decimal. */
+    bcdUSB: number;
+    /** USB-IF class code for the device. */
+    bDeviceClass: number;
+    /** USB-IF subclass code for the device, qualified by the bDeviceClass value. */
+    bDeviceSubClass: number;
+    /** USB-IF protocol code for the device, qualified by the bDeviceClass and bDeviceSubClass values. */
+    bDeviceProtocol: number;
+    /** Maximum packet size for endpoint 0. */
+    bMaxPacketSize0: number;
+    /** USB-IF vendor ID. */
+    idVendor: number;
+    /** USB-IF product ID. */
+    idProduct: number;
+    /** Device release number in binary-coded decimal. */
+    bcdDevice: number;
+    /** Index of string descriptor describing manufacturer. */
+    iManufacturer: number;
+    /** Index of string descriptor describing product. */
+    iProduct: number;
+    /** Index of string descriptor containing device serial number. */
+    iSerialNumber: number;
+    /** Number of possible configurations. */
+    bNumConfigurations: number;
+}
+/** A structure representing the standard USB configuration descriptor */
+export interface ConfigDescriptor {
+    /** Size of this descriptor (in bytes) */
+    bLength: number;
+    /** Descriptor type. */
+    bDescriptorType: number;
+    /** Total length of data returned for this configuration. */
+    wTotalLength: number;
+    /** Number of interfaces supported by this configuration. */
+    bNumInterfaces: number;
+    /** Identifier value for this configuration. */
+    bConfigurationValue: number;
+    /** Index of string descriptor describing this configuration. */
+    iConfiguration: number;
+    /** Configuration characteristics. */
+    bmAttributes: number;
+    /** Maximum power consumption of the USB device from this bus in this configuration when the device is fully operation. */
+    bMaxPower: number;
+    /** Extra descriptors. */
+    extra: Buffer;
+    /** Array of interfaces supported by this configuration. */
+    interfaces: InterfaceDescriptor[][];
+}
+/** A structure representing the standard USB interface descriptor */
+export interface InterfaceDescriptor {
+    /** Size of this descriptor (in bytes) */
+    bLength: number;
+    /** Descriptor type. */
+    bDescriptorType: number;
+    /** Number of this interface. */
+    bInterfaceNumber: number;
+    /** Value used to select this alternate setting for this interface. */
+    bAlternateSetting: number;
+    /** Number of endpoints used by this interface (excluding the control endpoint). */
+    bNumEndpoints: number;
+    /** USB-IF class code for this interface. */
+    bInterfaceClass: number;
+    /** USB-IF subclass code for this interface, qualified by the bInterfaceClass value. */
+    bInterfaceSubClass: number;
+    /** USB-IF protocol code for this interface, qualified by the bInterfaceClass and bInterfaceSubClass values. */
+    bInterfaceProtocol: number;
+    /** Index of string descriptor describing this interface. */
+    iInterface: number;
+    /** Extra descriptors. */
+    extra: Buffer;
+    /** Array of endpoint descriptors. */
+    endpoints: EndpointDescriptor[];
+}
+/** A structure representing the standard USB endpoint descriptor */
+export interface EndpointDescriptor {
+    /** Size of this descriptor (in bytes) */
+    bLength: number;
+    /** Descriptor type. */
+    bDescriptorType: number;
+    /** The address of the endpoint described by this descriptor. */
+    bEndpointAddress: number;
+    /** Attributes which apply to the endpoint when it is configured using the bConfigurationValue. */
+    bmAttributes: number;
+    /** Maximum packet size this endpoint is capable of sending/receiving. */
+    wMaxPacketSize: number;
+    /** Interval for polling endpoint for data transfers. */
+    bInterval: number;
+    /** For audio devices only: the rate at which synchronization feedback is provided. */
+    bRefresh: number;
+    /** For audio devices only: the address if the synch endpoint. */
+    bSynchAddress: number;
+    /**
+     * Extra descriptors.
+     *
+     * If libusb encounters unknown endpoint descriptors, it will store them here, should you wish to parse them.
+     */
+    extra: Buffer;
+}
+/** A generic representation of a BOS Device Capability descriptor */
+export interface CapabilityDescriptor {
+    /** Size of this descriptor (in bytes) */
+    bLength: number;
+    /** Descriptor type. */
+    bDescriptorType: number;
+    /** Device Capability type. */
+    bDevCapabilityType: number;
+    /** Device Capability data (bLength - 3 bytes) */
+    dev_capability_data: Buffer;
+}
+/** A structure representing the Binary Device Object Store (BOS) descriptor */
+export interface BosDescriptor {
+    /** Size of this descriptor (in bytes) */
+    bLength: number;
+    /** Descriptor type. */
+    bDescriptorType: number;
+    /** Length of this descriptor and all of its sub descriptors. */
+    wTotalLength: number;
+    /** The number of separate device capability descriptors in the BOS. */
+    bNumDeviceCaps: number;
+    /** Device Capability Descriptors */
+    capabilities: CapabilityDescriptor[];
+}

package/dist/usb/descriptors.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=descriptors.js.map

package/dist/usb/descriptors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"descriptors.js","sourceRoot":"","sources":["../../tsc/usb/descriptors.ts"],"names":[],"mappings":""}