usb 2.5.1 → 2.5.2

package/tsc/usb/device.ts

@@ -1,331 +0,0 @@
-import * as usb from './bindings';
-import { Interface } from './interface';
-import { Capability } from './capability';
-import { BosDescriptor, ConfigDescriptor } from './descriptors';
-
-const isBuffer = (obj: number | Uint8Array | undefined): obj is Uint8Array => !!obj && obj instanceof Uint8Array;
-const DEFAULT_TIMEOUT = 1000;
-
-export class ExtendedDevice {
-    /**
-     * List of Interface objects for the interfaces of the default configuration of the device.
-     */
-    public interfaces: Interface[] | undefined;
-
-    private _timeout = DEFAULT_TIMEOUT;
-    /**
-     * Timeout in milliseconds to use for control transfers.
-     */
-    public get timeout(): number {
-        return this._timeout || DEFAULT_TIMEOUT;
-    }
-    public set timeout(value: number) {
-        this._timeout = value;
-    }
-
-    /**
-     * Object with properties for the fields of the active configuration descriptor.
-     */
-    public get configDescriptor(): ConfigDescriptor | undefined {
-        try {
-            return (this as unknown as usb.Device).__getConfigDescriptor();
-        } catch (e) {
-            // Check descriptor exists
-            if (e.errno === usb.LIBUSB_ERROR_NOT_FOUND) {
-                return undefined;
-            }
-            throw e;
-        }
-    }
-
-    /**
-     * Contains all config descriptors of the device (same structure as .configDescriptor above)
-     */
-    public get allConfigDescriptors(): ConfigDescriptor[] {
-        try {
-            return (this as unknown as usb.Device).__getAllConfigDescriptors();
-        } catch (e) {
-            // Check descriptors exist
-            if (e.errno === usb.LIBUSB_ERROR_NOT_FOUND) {
-                return [];
-            }
-            throw e;
-        }
-    }
-
-    /**
-     * Contains the parent of the device, such as a hub. If there is no parent this property is set to `null`.
-     */
-    public get parent(): usb.Device {
-        return (this as unknown as usb.Device).__getParent();
-    }
-
-    /**
-     * Open the device.
-     * @param defaultConfig
-     */
-    public open(this: usb.Device, defaultConfig = true): void {
-        this.__open();
-        if (defaultConfig === false) {
-            return;
-        }
-        this.interfaces = [];
-        const len = this.configDescriptor ? this.configDescriptor.interfaces.length : 0;
-        for (let i = 0; i < len; i++) {
-            this.interfaces[i] = new Interface(this, i);
-        }
-    }
-
-    /**
-     * Close the device.
-     *
-     * The device must be open to use this method.
-     */
-    public close(this: usb.Device): void {
-        this.__close();
-        this.interfaces = undefined;
-    }
-
-    /**
-     * 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
-     */
-    public setConfiguration(this: usb.Device, desired: number, callback?: (error: usb.LibUSBException | undefined) => void): void {
-        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(this, i);
-                }
-            }
-            if (callback) {
-                callback.call(this, error);
-            }
-        });
-    }
-
-    /**
-     * 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
-     */
-    public controlTransfer(this: usb.Device, bmRequestType: number, bRequest: number, wValue: number, wIndex: number, data_or_length: number | Buffer,
-        callback?: (error: usb.LibUSBException | undefined, buffer: Buffer | number | undefined) => void): usb.Device {
-        const isIn = !!(bmRequestType & usb.LIBUSB_ENDPOINT_IN);
-        const wLength = isIn ? data_or_length as number : (data_or_length as Buffer).length;
-
-        if (isIn) {
-            if (!(data_or_length >= 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)');
-            }
-        }
-
-        // Buffer for the setup packet
-        // http://libusbx.sourceforge.net/api-1.0/structlibusb__control__setup.html
-        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 as Buffer, usb.LIBUSB_CONTROL_SETUP_SIZE);
-        }
-
-        const transfer = new usb.Transfer(this, 0, usb.LIBUSB_TRANSFER_TYPE_CONTROL, this.timeout,
-            (error, buf, actual) => {
-                if (callback) {
-                    if (isIn) {
-                        callback.call(this, error, buf.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, undefined));
-            }
-        }
-        return this;
-    }
-
-    /**
-     * Return the interface with the specified interface number.
-     *
-     * The device must be open to use this method.
-     * @param addr
-     */
-    public interface(this: usb.Device, addr: number): Interface {
-        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
-     */
-    public getStringDescriptor(this: usb.Device, desc_index: number, callback: (error?: usb.LibUSBException, value?: string) => void): void {
-        // Index 0 indicates null
-        if (desc_index === 0) {
-            callback();
-            return;
-        }
-
-        const langid = 0x0409;
-        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(undefined, isBuffer(buffer) ? buffer.toString('utf16le', 2) : undefined);
-            }
-        );
-    }
-
-    /**
-     * 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
-     */
-    public getBosDescriptor(this: usb.Device, callback: (error?: usb.LibUSBException, descriptor?: BosDescriptor) => void): void {
-        if (this._bosDescriptor) {
-            // Cached descriptor
-            return callback(undefined, this._bosDescriptor);
-        }
-
-        if (this.deviceDescriptor.bcdUSB < 0x201) {
-            // BOS is only supported from USB 2.0.1
-            return callback(undefined, undefined);
-        }
-
-        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) {
-                    // Check BOS descriptor exists
-                    if (error.errno === usb.LIBUSB_TRANSFER_STALL) return callback(undefined, undefined);
-                    return callback(error, undefined);
-                }
-
-                if (!isBuffer(buffer)) {
-                    return callback(undefined, undefined);
-                }
-
-                const totalLength = buffer.readUInt16LE(2);
-                this.controlTransfer(
-                    usb.LIBUSB_ENDPOINT_IN,
-                    usb.LIBUSB_REQUEST_GET_DESCRIPTOR,
-                    (usb.LIBUSB_DT_BOS << 8),
-                    0,
-                    totalLength,
-                    (error, buffer) => {
-                        if (error) {
-                            // Check BOS descriptor exists
-                            if (error.errno === usb.LIBUSB_TRANSFER_STALL) return callback(undefined, undefined);
-                            return callback(error, undefined);
-                        }
-
-                        if (!isBuffer(buffer)) {
-                            return callback(undefined, undefined);
-                        }
-
-                        const descriptor: BosDescriptor = {
-                            bLength: buffer.readUInt8(0),
-                            bDescriptorType: buffer.readUInt8(1),
-                            wTotalLength: buffer.readUInt16LE(2),
-                            bNumDeviceCaps: buffer.readUInt8(4),
-                            capabilities: []
-                        };
-
-                        let i = usb.LIBUSB_DT_BOS_SIZE;
-                        while (i < descriptor.wTotalLength) {
-                            const capability = {
-                                bLength: buffer.readUInt8(i + 0),
-                                bDescriptorType: buffer.readUInt8(i + 1),
-                                bDevCapabilityType: buffer.readUInt8(i + 2),
-                                dev_capability_data: buffer.slice(i + 3, i + buffer.readUInt8(i + 0))
-                            };
-
-                            descriptor.capabilities.push(capability);
-                            i += capability.bLength;
-                        }
-
-                        // Cache descriptor
-                        this._bosDescriptor = descriptor;
-                        callback(undefined, 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
-     */
-    public getCapabilities(this: usb.Device, callback: (error: usb.LibUSBException | undefined, capabilities?: Capability[]) => void): void {
-        const capabilities: Capability[] = [];
-
-        this.getBosDescriptor((error, descriptor) => {
-            if (error) return callback(error, undefined);
-
-            const len = descriptor ? descriptor.capabilities.length : 0;
-            for (let i = 0; i < len; i++) {
-                capabilities.push(new Capability(this, i));
-            }
-
-            callback(undefined, capabilities);
-        });
-    }
-}

package/tsc/usb/endpoint.ts

@@ -1,229 +0,0 @@
-import { EventEmitter } from 'events';
-import { LibUSBException, LIBUSB_TRANSFER_CANCELLED, Transfer, Device } from './bindings';
-import { EndpointDescriptor } from './descriptors';
-
-const isBuffer = (obj: ArrayBuffer | Buffer): obj is Uint8Array => obj && obj instanceof Uint8Array;
-
-/** Common base for InEndpoint and OutEndpoint. */
-export abstract class Endpoint extends EventEmitter {
-    public address: number;
-
-    /** Endpoint direction: `"in"` or `"out"`. */
-    public abstract direction: 'in' | 'out';
-
-    /** Endpoint type: `usb.LIBUSB_TRANSFER_TYPE_BULK`, `usb.LIBUSB_TRANSFER_TYPE_INTERRUPT`, or `usb.LIBUSB_TRANSFER_TYPE_ISOCHRONOUS`. */
-    public transferType: number;
-
-    /** Sets the timeout in milliseconds for transfers on this endpoint. The default, `0`, is infinite timeout. */
-    public timeout = 0;
-
-    /** Object with fields from the endpoint descriptor -- see libusb documentation or USB spec. */
-    public descriptor: EndpointDescriptor;
-
-    constructor(protected device: Device, descriptor: EndpointDescriptor) {
-        super();
-        this.descriptor = descriptor;
-        this.address = descriptor.bEndpointAddress;
-        this.transferType = descriptor.bmAttributes & 0x03;
-    }
-
-    /** Clear the halt/stall condition for this endpoint. */
-    public clearHalt(callback: (error: LibUSBException | undefined) => void): void {
-        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.
-     */
-    public makeTransfer(timeout: number, callback: (error: LibUSBException | undefined, buffer: Buffer, actualLength: number) => void): Transfer {
-        return new Transfer(this.device, this.address, this.transferType, timeout, callback);
-    }
-}
-
-/** Endpoints in the IN direction (device->PC) have this type. */
-export class InEndpoint extends Endpoint {
-
-    /** Endpoint direction. */
-    public direction: 'in' | 'out' = 'in';
-
-    protected pollTransfers: Transfer[] = [];
-    protected pollTransferSize = 0;
-    protected pollPending = 0;
-    public pollActive = false;
-
-    constructor(device: Device, descriptor: EndpointDescriptor) {
-        super(device, descriptor);
-    }
-
-    /**
-     * 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
-     */
-    public transfer(length: number, callback: (error: LibUSBException | undefined, data?: Buffer) => void): InEndpoint {
-        const buffer = Buffer.alloc(length);
-
-        const cb = (error: LibUSBException | undefined, _buffer?: Buffer, actualLength?: number) => {
-            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
-     */
-    public startPoll(nTransfers?: number, transferSize?: number, _callback?: (error: LibUSBException | undefined, buffer: Buffer, actualLength: number) => void): Transfer[] {
-        const transferDone = (error: LibUSBException | undefined, transfer: Transfer, buffer: Buffer, actualLength: number) => {
-            if (!error) {
-                this.emit('data', buffer.slice(0, actualLength));
-            } else if (error.errno != LIBUSB_TRANSFER_CANCELLED) {
-                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');
-                }
-            }
-        };
-
-        const startTransfer = (transfer: 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 (this: Transfer, error, buffer, actualLength) {
-            transferDone(error, this, buffer, actualLength);
-        });
-        this.pollTransfers.forEach(startTransfer);
-        this.pollPending = this.pollTransfers.length;
-        return this.pollTransfers;
-    }
-
-    protected startPollTransfers(nTransfers = 3, transferSize = this.descriptor.wMaxPacketSize, callback: (error: LibUSBException | undefined, buffer: Buffer, actualLength: number) => void): Transfer[] {
-        if (this.pollActive) {
-            throw new Error('Polling already active');
-        }
-
-        this.pollTransferSize = transferSize;
-        this.pollActive = true;
-        this.pollPending = 0;
-
-        const transfers: Transfer[] = [];
-        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
-     */
-    public stopPoll(callback?: () => void): void {
-        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);
-    }
-}
-
-/** Endpoints in the OUT direction (PC->device) have this type. */
-export class OutEndpoint extends Endpoint {
-
-    /** Endpoint direction. */
-    public direction: 'in' | 'out' = 'out';
-
-    /**
-     * 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
-     */
-    public transfer(buffer: Buffer, callback?: (error: LibUSBException | undefined, actual: number) => void): OutEndpoint {
-        if (!buffer) {
-            buffer = Buffer.alloc(0);
-        } else if (!isBuffer(buffer)) {
-            buffer = Buffer.from(buffer);
-        }
-
-        const cb = (error: LibUSBException | undefined, _buffer?: Buffer, actual?: number) => {
-            if (callback) {
-                callback.call(this, error, actual || 0);
-            }
-        };
-
-        try {
-            this.makeTransfer(this.timeout, cb).submit(buffer);
-        } catch (e) {
-            process.nextTick(() => cb(e));
-        }
-
-        return this;
-    }
-
-    public transferWithZLP(buffer: Buffer, callback: (error: LibUSBException | undefined) => void): void {
-        if (buffer.length % this.descriptor.wMaxPacketSize === 0) {
-            this.transfer(buffer);
-            this.transfer(Buffer.alloc(0), callback);
-        } else {
-            this.transfer(buffer, callback);
-        }
-    }
-}

package/tsc/usb/index.ts

@@ -1,149 +0,0 @@
-import { EventEmitter } from 'events';
-import { ExtendedDevice } from './device';
-import * as usb from './bindings';
-
-if (usb.INIT_ERROR) {
-    /* eslint-disable no-console */
-    console.warn('Failed to initialize libusb.');
-}
-
-Object.setPrototypeOf(usb, EventEmitter.prototype);
-
-Object.getOwnPropertyNames(ExtendedDevice.prototype).forEach(name => {
-    Object.defineProperty(usb.Device.prototype, name, Object.getOwnPropertyDescriptor(ExtendedDevice.prototype, name) || Object.create(null));
-});
-
-interface EventListeners<T> {
-    newListener: keyof T;
-    removeListener: keyof T;
-}
-
-interface DeviceIds {
-    idVendor: number;
-    idProduct: number;
-}
-
-declare module './bindings' {
-
-    /* eslint-disable @typescript-eslint/no-empty-interface */
-    interface Device extends ExtendedDevice { }
-
-    interface DeviceEvents extends EventListeners<DeviceEvents> {
-        attach: Device;
-        detach: Device;
-        attachIds: DeviceIds;
-        detachIds: DeviceIds;
-    }
-
-    function addListener<K extends keyof DeviceEvents>(event: K, listener: (arg: DeviceEvents[K]) => void): void;
-    function removeListener<K extends keyof DeviceEvents>(event: K, listener: (arg: DeviceEvents[K]) => void): void;
-    function on<K extends keyof DeviceEvents>(event: K, listener: (arg: DeviceEvents[K]) => void): void;
-    function off<K extends keyof DeviceEvents>(event: K, listener: (arg: DeviceEvents[K]) => void): void;
-    function once<K extends keyof DeviceEvents>(event: K, listener: (arg: DeviceEvents[K]) => void): void;
-    function listeners<K extends keyof DeviceEvents>(event: K): ((arg: DeviceEvents[K]) => void)[];
-    function rawListeners<K extends keyof DeviceEvents>(event: K): ((arg: DeviceEvents[K]) => void)[];
-    function removeAllListeners<K extends keyof DeviceEvents>(event?: K): void;
-    function emit<K extends keyof DeviceEvents>(event: K, arg: DeviceEvents[K]): boolean;
-    function listenerCount<K extends keyof DeviceEvents>(event: K): number;
-}
-
-// Hotplug support
-const hotplugSupported = usb._supportedHotplugEvents();
-
-// Devices delta support for non-libusb hotplug events
-// This methd needs to be used for attach/detach IDs (hotplugSupportType === 2) rather than a lookup because vid/pid are not unique
-let hotPlugDevices = new Set<usb.Device>();
-const emitHotplugEvents = () => {
-    // Collect current devices
-    const devices = new Set(usb.getDeviceList());
-
-    // Find attached devices
-    for (const device of devices) {
-        if (!hotPlugDevices.has(device)) {
-            usb.emit('attach', device);
-        }
-    }
-
-    // Find detached devices
-    for (const device of hotPlugDevices) {
-        if (!devices.has(device)) {
-            usb.emit('detach', device);
-        }
-    }
-
-    hotPlugDevices = devices;
-};
-
-// Polling mechanism for checking device changes where hotplug detection is not available
-let pollingHotplug = false;
-const pollHotplug = (start = false) => {
-    if (start) {
-        pollingHotplug = true;
-    } else if (!pollingHotplug) {
-        return;
-    } else {
-        emitHotplugEvents();
-    }
-
-    setTimeout(() => pollHotplug(), 500);
-};
-
-// Hotplug control
-const startHotplug = () => {
-    if (hotplugSupported !== 1) {
-        // Collect initial devices when not using libusb
-        hotPlugDevices = new Set(usb.getDeviceList());
-    }
-
-    if (hotplugSupported) {
-        // Use hotplug event emitters
-        usb._enableHotplugEvents();
-
-        if (hotplugSupported === 2) {
-            // Use hotplug ID events to trigger a change check
-            usb.on('attachIds', emitHotplugEvents);
-            usb.on('detachIds', emitHotplugEvents);
-        }
-    } else {
-        // Fallback to using polling to check for changes
-        pollHotplug(true);
-    }
-};
-
-const stopHotplug = () => {
-    if (hotplugSupported) {
-        // Disable hotplug events
-        usb._disableHotplugEvents();
-
-        if (hotplugSupported === 2) {
-            // Remove hotplug ID event listeners
-            usb.off('attachIds', emitHotplugEvents);
-            usb.off('detachIds', emitHotplugEvents);
-        }
-    } else {
-        // Stop polling
-        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();
-    }
-});
-
-export = usb;