usb 2.2.0 → 2.4.0

package/dist/webusb/webusb-device.js

@@ -50,7 +50,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.WebUSBDevice = void 0;
 var usb = require("../usb");
 var util_1 = require("util");
-var mutex_1 = require("./mutex");
 var LIBUSB_TRANSFER_TYPE_MASK = 0x03;
 var ENDPOINT_NUMBER_MASK = 0x7f;
 var CLEAR_FEATURE = 0x01;
@@ -62,7 +61,6 @@ var WebUSBDevice = /** @class */ (function () {
     function WebUSBDevice(device) {
         this.device = device;
         this.configurations = [];
-        this.deviceMutex = new mutex_1.Mutex();
         var usbVersion = this.decodeVersion(device.deviceDescriptor.bcdUSB);
         this.usbVersionMajor = usbVersion.major;
         this.usbVersionMinor = usbVersion.minor;
@@ -117,59 +115,46 @@ var WebUSBDevice = /** @class */ (function () {
     });
     WebUSBDevice.prototype.open = function () {
         return __awaiter(this, void 0, void 0, function () {
-            var error_1;
             return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        _a.trys.push([0, 2, 3, 4]);
-                        return [4 /*yield*/, this.deviceMutex.lock()];
-                    case 1:
-                        _a.sent();
-                        if (this.opened) {
-                            return [2 /*return*/];
-                        }
-                        this.device.open();
-                        return [3 /*break*/, 4];
-                    case 2:
-                        error_1 = _a.sent();
-                        throw new Error("open error: " + error_1);
-                    case 3:
-                        this.deviceMutex.unlock();
-                        return [7 /*endfinally*/];
-                    case 4: return [2 /*return*/];
+                try {
+                    if (this.opened) {
+                        return [2 /*return*/];
+                    }
+                    this.device.open();
+                }
+                catch (error) {
+                    throw new Error("open error: " + error);
                 }
+                return [2 /*return*/];
             });
         });
     };
     WebUSBDevice.prototype.close = function () {
         var _a;
         return __awaiter(this, void 0, void 0, function () {
-            var _b, _c, iface, e_1_1, _error_1, error_2;
+            var _b, _c, iface, e_1_1, _error_1, error_1;
             var e_1, _d;
             return __generator(this, function (_e) {
                 switch (_e.label) {
                     case 0:
-                        _e.trys.push([0, 13, 14, 15]);
-                        return [4 /*yield*/, this.deviceMutex.lock()];
-                    case 1:
-                        _e.sent();
+                        _e.trys.push([0, 12, , 13]);
                         if (!this.opened) {
                             return [2 /*return*/];
                         }
+                        _e.label = 1;
+                    case 1:
+                        _e.trys.push([1, 10, , 11]);
+                        if (!this.configuration) return [3 /*break*/, 9];
                         _e.label = 2;
                     case 2:
-                        _e.trys.push([2, 11, , 12]);
-                        if (!this.configuration) return [3 /*break*/, 10];
+                        _e.trys.push([2, 7, 8, 9]);
+                        _b = __values((_a = this.configuration) === null || _a === void 0 ? void 0 : _a.interfaces), _c = _b.next();
                         _e.label = 3;
                     case 3:
-                        _e.trys.push([3, 8, 9, 10]);
-                        _b = __values((_a = this.configuration) === null || _a === void 0 ? void 0 : _a.interfaces), _c = _b.next();
-                        _e.label = 4;
-                    case 4:
-                        if (!!_c.done) return [3 /*break*/, 7];
+                        if (!!_c.done) return [3 /*break*/, 6];
                         iface = _c.value;
                         return [4 /*yield*/, this._releaseInterface(iface.interfaceNumber)];
-                    case 5:
+                    case 4:
                         _e.sent();
                         // Re-create the USBInterface to set the claimed attribute
                         this.configuration.interfaces[this.configuration.interfaces.indexOf(iface)] = {
@@ -178,49 +163,42 @@ var WebUSBDevice = /** @class */ (function () {
                             alternates: iface.alternates,
                             claimed: false
                         };
-                        _e.label = 6;
-                    case 6:
+                        _e.label = 5;
+                    case 5:
                         _c = _b.next();
-                        return [3 /*break*/, 4];
-                    case 7: return [3 /*break*/, 10];
-                    case 8:
+                        return [3 /*break*/, 3];
+                    case 6: return [3 /*break*/, 9];
+                    case 7:
                         e_1_1 = _e.sent();
                         e_1 = { error: e_1_1 };
-                        return [3 /*break*/, 10];
-                    case 9:
+                        return [3 /*break*/, 9];
+                    case 8:
                         try {
                             if (_c && !_c.done && (_d = _b.return)) _d.call(_b);
                         }
                         finally { if (e_1) throw e_1.error; }
                         return [7 /*endfinally*/];
-                    case 10: return [3 /*break*/, 12];
-                    case 11:
+                    case 9: return [3 /*break*/, 11];
+                    case 10:
                         _error_1 = _e.sent();
-                        return [3 /*break*/, 12];
-                    case 12:
+                        return [3 /*break*/, 11];
+                    case 11:
                         this.device.close();
-                        return [3 /*break*/, 15];
-                    case 13:
-                        error_2 = _e.sent();
-                        throw new Error("close error: " + error_2);
-                    case 14:
-                        this.deviceMutex.unlock();
-                        return [7 /*endfinally*/];
-                    case 15: return [2 /*return*/];
+                        return [3 /*break*/, 13];
+                    case 12:
+                        error_1 = _e.sent();
+                        throw new Error("close error: " + error_1);
+                    case 13: return [2 /*return*/];
                 }
             });
         });
     };
     WebUSBDevice.prototype.selectConfiguration = function (configurationValue) {
         return __awaiter(this, void 0, void 0, function () {
-            var config, setConfiguration, error_3;
+            var config, setConfiguration, error_2;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
-                        _a.trys.push([0, , 6, 7]);
-                        return [4 /*yield*/, this.deviceMutex.lock()];
-                    case 1:
-                        _a.sent();
                         if (!this.opened || !this.device.configDescriptor) {
                             throw new Error('selectConfiguration error: invalid state');
                         }
@@ -231,22 +209,18 @@ var WebUSBDevice = /** @class */ (function () {
                         if (!config) {
                             throw new Error('selectConfiguration error: configuration not found');
                         }
-                        _a.label = 2;
-                    case 2:
-                        _a.trys.push([2, 4, , 5]);
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 3, , 4]);
                         setConfiguration = util_1.promisify(this.device.setConfiguration).bind(this.device);
                         return [4 /*yield*/, setConfiguration(configurationValue)];
-                    case 3:
+                    case 2:
                         _a.sent();
-                        return [3 /*break*/, 5];
-                    case 4:
-                        error_3 = _a.sent();
-                        throw new Error("selectConfiguration error: " + error_3);
-                    case 5: return [3 /*break*/, 7];
-                    case 6:
-                        this.deviceMutex.unlock();
-                        return [7 /*endfinally*/];
-                    case 7: return [2 /*return*/];
+                        return [3 /*break*/, 4];
+                    case 3:
+                        error_2 = _a.sent();
+                        throw new Error("selectConfiguration error: " + error_2);
+                    case 4: return [2 /*return*/];
                 }
             });
         });
@@ -255,44 +229,33 @@ var WebUSBDevice = /** @class */ (function () {
         return __awaiter(this, void 0, void 0, function () {
             var iface;
             return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        _a.trys.push([0, , 2, 3]);
-                        return [4 /*yield*/, this.deviceMutex.lock()];
-                    case 1:
-                        _a.sent();
-                        if (!this.opened) {
-                            throw new Error('claimInterface error: invalid state');
-                        }
-                        if (!this.configuration) {
-                            throw new Error('claimInterface error: interface not found');
-                        }
-                        iface = this.configuration.interfaces.find(function (usbInterface) { return usbInterface.interfaceNumber === interfaceNumber; });
-                        if (!iface) {
-                            throw new Error('claimInterface error: interface not found');
-                        }
-                        if (iface.claimed) {
-                            return [2 /*return*/];
-                        }
-                        try {
-                            this.device.interface(interfaceNumber).claim();
-                            // Re-create the USBInterface to set the claimed attribute
-                            this.configuration.interfaces[this.configuration.interfaces.indexOf(iface)] = {
-                                interfaceNumber: interfaceNumber,
-                                alternate: iface.alternate,
-                                alternates: iface.alternates,
-                                claimed: true
-                            };
-                        }
-                        catch (error) {
-                            throw new Error("claimInterface error: " + error);
-                        }
-                        return [3 /*break*/, 3];
-                    case 2:
-                        this.deviceMutex.unlock();
-                        return [7 /*endfinally*/];
-                    case 3: return [2 /*return*/];
+                if (!this.opened) {
+                    throw new Error('claimInterface error: invalid state');
                 }
+                if (!this.configuration) {
+                    throw new Error('claimInterface error: interface not found');
+                }
+                iface = this.configuration.interfaces.find(function (usbInterface) { return usbInterface.interfaceNumber === interfaceNumber; });
+                if (!iface) {
+                    throw new Error('claimInterface error: interface not found');
+                }
+                if (iface.claimed) {
+                    return [2 /*return*/];
+                }
+                try {
+                    this.device.interface(interfaceNumber).claim();
+                    // Re-create the USBInterface to set the claimed attribute
+                    this.configuration.interfaces[this.configuration.interfaces.indexOf(iface)] = {
+                        interfaceNumber: interfaceNumber,
+                        alternate: iface.alternate,
+                        alternates: iface.alternates,
+                        claimed: true
+                    };
+                }
+                catch (error) {
+                    throw new Error("claimInterface error: " + error);
+                }
+                return [2 /*return*/];
             });
         });
     };
@@ -301,13 +264,8 @@ var WebUSBDevice = /** @class */ (function () {
             var iface;
             return __generator(this, function (_a) {
                 switch (_a.label) {
-                    case 0:
-                        _a.trys.push([0, , 3, 4]);
-                        return [4 /*yield*/, this.deviceMutex.lock()];
+                    case 0: return [4 /*yield*/, this._releaseInterface(interfaceNumber)];
                     case 1:
-                        _a.sent();
-                        return [4 /*yield*/, this._releaseInterface(interfaceNumber)];
-                    case 2:
                         _a.sent();
                         if (this.configuration) {
                             iface = this.configuration.interfaces.find(function (usbInterface) { return usbInterface.interfaceNumber === interfaceNumber; });
@@ -321,25 +279,17 @@ var WebUSBDevice = /** @class */ (function () {
                                 };
                             }
                         }
-                        return [3 /*break*/, 4];
-                    case 3:
-                        this.deviceMutex.unlock();
-                        return [7 /*endfinally*/];
-                    case 4: return [2 /*return*/];
+                        return [2 /*return*/];
                 }
             });
         });
     };
     WebUSBDevice.prototype.selectAlternateInterface = function (interfaceNumber, alternateSetting) {
         return __awaiter(this, void 0, void 0, function () {
-            var iface, iface_1, setAltSetting, error_4;
+            var iface, iface_1, setAltSetting, error_3;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
-                        _a.trys.push([0, , 6, 7]);
-                        return [4 /*yield*/, this.deviceMutex.lock()];
-                    case 1:
-                        _a.sent();
                         if (!this.opened) {
                             throw new Error('selectAlternateInterface error: invalid state');
                         }
@@ -353,230 +303,190 @@ var WebUSBDevice = /** @class */ (function () {
                         if (!iface.claimed) {
                             throw new Error('selectAlternateInterface error: invalid state');
                         }
-                        _a.label = 2;
-                    case 2:
-                        _a.trys.push([2, 4, , 5]);
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 3, , 4]);
                         iface_1 = this.device.interface(interfaceNumber);
                         setAltSetting = util_1.promisify(iface_1.setAltSetting).bind(iface_1);
                         return [4 /*yield*/, setAltSetting(alternateSetting)];
-                    case 3:
+                    case 2:
                         _a.sent();
-                        return [3 /*break*/, 5];
-                    case 4:
-                        error_4 = _a.sent();
-                        throw new Error("selectAlternateInterface error: " + error_4);
-                    case 5: return [3 /*break*/, 7];
-                    case 6:
-                        this.deviceMutex.unlock();
-                        return [7 /*endfinally*/];
-                    case 7: return [2 /*return*/];
+                        return [3 /*break*/, 4];
+                    case 3:
+                        error_3 = _a.sent();
+                        throw new Error("selectAlternateInterface error: " + error_3);
+                    case 4: return [2 /*return*/];
                 }
             });
         });
     };
     WebUSBDevice.prototype.controlTransferIn = function (setup, length) {
         return __awaiter(this, void 0, void 0, function () {
-            var type, controlTransfer, result, error_5;
+            var type, controlTransfer, result, error_4;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
-                        _a.trys.push([0, 3, 4, 5]);
-                        return [4 /*yield*/, this.deviceMutex.lock()];
-                    case 1:
-                        _a.sent();
+                        _a.trys.push([0, 2, , 3]);
                         type = this.controlTransferParamsToType(setup, usb.LIBUSB_ENDPOINT_IN);
                         controlTransfer = util_1.promisify(this.device.controlTransfer).bind(this.device);
                         return [4 /*yield*/, controlTransfer(type, setup.request, setup.value, setup.index, length)];
-                    case 2:
+                    case 1:
                         result = _a.sent();
                         return [2 /*return*/, {
                                 data: result ? new DataView(new Uint8Array(result).buffer) : undefined,
                                 status: 'ok'
                             }];
-                    case 3:
-                        error_5 = _a.sent();
-                        if (error_5.errno === usb.LIBUSB_TRANSFER_STALL) {
+                    case 2:
+                        error_4 = _a.sent();
+                        if (error_4.errno === usb.LIBUSB_TRANSFER_STALL) {
                             return [2 /*return*/, {
                                     status: 'stall'
                                 }];
                         }
-                        if (error_5.errno === usb.LIBUSB_TRANSFER_OVERFLOW) {
+                        if (error_4.errno === usb.LIBUSB_TRANSFER_OVERFLOW) {
                             return [2 /*return*/, {
                                     status: 'babble'
                                 }];
                         }
-                        throw new Error("controlTransferIn error: " + error_5);
-                    case 4:
-                        this.deviceMutex.unlock();
-                        return [7 /*endfinally*/];
-                    case 5: return [2 /*return*/];
+                        throw new Error("controlTransferIn error: " + error_4);
+                    case 3: return [2 /*return*/];
                 }
             });
         });
     };
     WebUSBDevice.prototype.controlTransferOut = function (setup, data) {
         return __awaiter(this, void 0, void 0, function () {
-            var type, controlTransfer, buffer, bytesWritten, error_6;
+            var type, controlTransfer, buffer, bytesWritten, error_5;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
-                        _a.trys.push([0, 3, 4, 5]);
-                        return [4 /*yield*/, this.deviceMutex.lock()];
-                    case 1:
-                        _a.sent();
+                        _a.trys.push([0, 2, , 3]);
                         type = this.controlTransferParamsToType(setup, usb.LIBUSB_ENDPOINT_OUT);
                         controlTransfer = util_1.promisify(this.device.controlTransfer).bind(this.device);
                         buffer = data ? Buffer.from(data) : Buffer.alloc(0);
                         return [4 /*yield*/, controlTransfer(type, setup.request, setup.value, setup.index, buffer)];
-                    case 2:
+                    case 1:
                         bytesWritten = _a.sent();
                         return [2 /*return*/, {
                                 bytesWritten: bytesWritten,
                                 status: 'ok'
                             }];
-                    case 3:
-                        error_6 = _a.sent();
-                        if (error_6.errno === usb.LIBUSB_TRANSFER_STALL) {
+                    case 2:
+                        error_5 = _a.sent();
+                        if (error_5.errno === usb.LIBUSB_TRANSFER_STALL) {
                             return [2 /*return*/, {
                                     bytesWritten: 0,
                                     status: 'stall'
                                 }];
                         }
-                        throw new Error("controlTransferOut error: " + error_6);
-                    case 4:
-                        this.deviceMutex.unlock();
-                        return [7 /*endfinally*/];
-                    case 5: return [2 /*return*/];
+                        throw new Error("controlTransferOut error: " + error_5);
+                    case 3: return [2 /*return*/];
                 }
             });
         });
     };
     WebUSBDevice.prototype.clearHalt = function (direction, endpointNumber) {
         return __awaiter(this, void 0, void 0, function () {
-            var wIndex, controlTransfer, error_7;
+            var wIndex, controlTransfer, error_6;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
-                        _a.trys.push([0, 3, 4, 5]);
-                        return [4 /*yield*/, this.deviceMutex.lock()];
-                    case 1:
-                        _a.sent();
+                        _a.trys.push([0, 2, , 3]);
                         wIndex = endpointNumber | (direction === 'in' ? usb.LIBUSB_ENDPOINT_IN : usb.LIBUSB_ENDPOINT_OUT);
                         controlTransfer = util_1.promisify(this.device.controlTransfer).bind(this.device);
                         return [4 /*yield*/, controlTransfer(usb.LIBUSB_RECIPIENT_ENDPOINT, CLEAR_FEATURE, ENDPOINT_HALT, wIndex, 0)];
-                    case 2:
+                    case 1:
                         _a.sent();
-                        return [3 /*break*/, 5];
-                    case 3:
-                        error_7 = _a.sent();
-                        throw new Error("clearHalt error: " + error_7);
-                    case 4:
-                        this.deviceMutex.unlock();
-                        return [7 /*endfinally*/];
-                    case 5: return [2 /*return*/];
+                        return [3 /*break*/, 3];
+                    case 2:
+                        error_6 = _a.sent();
+                        throw new Error("clearHalt error: " + error_6);
+                    case 3: return [2 /*return*/];
                 }
             });
         });
     };
     WebUSBDevice.prototype.transferIn = function (endpointNumber, length) {
         return __awaiter(this, void 0, void 0, function () {
-            var endpoint, transfer, result, error_8;
+            var endpoint, transfer, result, error_7;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
-                        _a.trys.push([0, 3, 4, 5]);
-                        return [4 /*yield*/, this.deviceMutex.lock()];
-                    case 1:
-                        _a.sent();
+                        _a.trys.push([0, 2, , 3]);
                         endpoint = this.getEndpoint(endpointNumber | usb.LIBUSB_ENDPOINT_IN);
                         transfer = util_1.promisify(endpoint.transfer).bind(endpoint);
                         return [4 /*yield*/, transfer(length)];
-                    case 2:
+                    case 1:
                         result = _a.sent();
                         return [2 /*return*/, {
                                 data: result ? new DataView(new Uint8Array(result).buffer) : undefined,
                                 status: 'ok'
                             }];
-                    case 3:
-                        error_8 = _a.sent();
-                        if (error_8.errno === usb.LIBUSB_TRANSFER_STALL) {
+                    case 2:
+                        error_7 = _a.sent();
+                        if (error_7.errno === usb.LIBUSB_TRANSFER_STALL) {
                             return [2 /*return*/, {
                                     status: 'stall'
                                 }];
                         }
-                        if (error_8.errno === usb.LIBUSB_TRANSFER_OVERFLOW) {
+                        if (error_7.errno === usb.LIBUSB_TRANSFER_OVERFLOW) {
                             return [2 /*return*/, {
                                     status: 'babble'
                                 }];
                         }
-                        throw new Error("transferIn error: " + error_8);
-                    case 4:
-                        this.deviceMutex.unlock();
-                        return [7 /*endfinally*/];
-                    case 5: return [2 /*return*/];
+                        throw new Error("transferIn error: " + error_7);
+                    case 3: return [2 /*return*/];
                 }
             });
         });
     };
     WebUSBDevice.prototype.transferOut = function (endpointNumber, data) {
         return __awaiter(this, void 0, void 0, function () {
-            var endpoint, transfer, buffer, bytesWritten, error_9;
+            var endpoint, transfer, buffer, bytesWritten, error_8;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
-                        _a.trys.push([0, 3, 4, 5]);
-                        return [4 /*yield*/, this.deviceMutex.lock()];
-                    case 1:
-                        _a.sent();
+                        _a.trys.push([0, 2, , 3]);
                         endpoint = this.getEndpoint(endpointNumber | usb.LIBUSB_ENDPOINT_OUT);
                         transfer = util_1.promisify(endpoint.transfer).bind(endpoint);
                         buffer = Buffer.from(data);
                         return [4 /*yield*/, transfer(buffer)];
-                    case 2:
+                    case 1:
                         bytesWritten = _a.sent();
                         return [2 /*return*/, {
                                 bytesWritten: bytesWritten,
                                 status: 'ok'
                             }];
-                    case 3:
-                        error_9 = _a.sent();
-                        if (error_9.errno === usb.LIBUSB_TRANSFER_STALL) {
+                    case 2:
+                        error_8 = _a.sent();
+                        if (error_8.errno === usb.LIBUSB_TRANSFER_STALL) {
                             return [2 /*return*/, {
                                     bytesWritten: 0,
                                     status: 'stall'
                                 }];
                         }
-                        throw new Error("transferOut error: " + error_9);
-                    case 4:
-                        this.deviceMutex.unlock();
-                        return [7 /*endfinally*/];
-                    case 5: return [2 /*return*/];
+                        throw new Error("transferOut error: " + error_8);
+                    case 3: return [2 /*return*/];
                 }
             });
         });
     };
     WebUSBDevice.prototype.reset = function () {
         return __awaiter(this, void 0, void 0, function () {
-            var reset, error_10;
+            var reset, error_9;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
-                        _a.trys.push([0, 3, 4, 5]);
-                        return [4 /*yield*/, this.deviceMutex.lock()];
-                    case 1:
-                        _a.sent();
+                        _a.trys.push([0, 2, , 3]);
                         reset = util_1.promisify(this.device.reset).bind(this.device);
                         return [4 /*yield*/, reset()];
-                    case 2:
+                    case 1:
                         _a.sent();
-                        return [3 /*break*/, 5];
-                    case 3:
-                        error_10 = _a.sent();
-                        throw new Error("reset error: " + error_10);
-                    case 4:
-                        this.deviceMutex.unlock();
-                        return [7 /*endfinally*/];
-                    case 5: return [2 /*return*/];
+                        return [3 /*break*/, 3];
+                    case 2:
+                        error_9 = _a.sent();
+                        throw new Error("reset error: " + error_9);
+                    case 3: return [2 /*return*/];
                 }
             });
         });
@@ -604,44 +514,40 @@ var WebUSBDevice = /** @class */ (function () {
     };
     WebUSBDevice.prototype.initialize = function () {
         return __awaiter(this, void 0, void 0, function () {
-            var _a, _b, _c, _d, error_11;
+            var _a, _b, _c, _d, error_10;
             return __generator(this, function (_e) {
                 switch (_e.label) {
                     case 0:
-                        _e.trys.push([0, 6, 7, 8]);
-                        return [4 /*yield*/, this.deviceMutex.lock()];
-                    case 1:
-                        _e.sent();
+                        _e.trys.push([0, 5, 6, 7]);
                         if (!this.opened) {
                             this.device.open();
                         }
                         _a = this;
                         return [4 /*yield*/, this.getStringDescriptor(this.device.deviceDescriptor.iManufacturer)];
-                    case 2:
+                    case 1:
                         _a.manufacturerName = _e.sent();
                         _b = this;
                         return [4 /*yield*/, this.getStringDescriptor(this.device.deviceDescriptor.iProduct)];
-                    case 3:
+                    case 2:
                         _b.productName = _e.sent();
                         _c = this;
                         return [4 /*yield*/, this.getStringDescriptor(this.device.deviceDescriptor.iSerialNumber)];
-                    case 4:
+                    case 3:
                         _c.serialNumber = _e.sent();
                         _d = this;
                         return [4 /*yield*/, this.getConfigurations()];
-                    case 5:
+                    case 4:
                         _d.configurations = _e.sent();
-                        return [3 /*break*/, 8];
+                        return [3 /*break*/, 7];
+                    case 5:
+                        error_10 = _e.sent();
+                        throw new Error("initialize error: " + error_10);
                     case 6:
-                        error_11 = _e.sent();
-                        throw new Error("initialize error: " + error_11);
-                    case 7:
                         if (this.opened) {
                             this.device.close();
                         }
-                        this.deviceMutex.unlock();
                         return [7 /*endfinally*/];
-                    case 8: return [2 /*return*/];
+                    case 7: return [2 /*return*/];
                 }
             });
         });
@@ -656,7 +562,7 @@ var WebUSBDevice = /** @class */ (function () {
     };
     WebUSBDevice.prototype.getStringDescriptor = function (index) {
         return __awaiter(this, void 0, void 0, function () {
-            var getStringDescriptor, buffer, error_12;
+            var getStringDescriptor, buffer, error_11;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
@@ -667,7 +573,7 @@ var WebUSBDevice = /** @class */ (function () {
                         buffer = _a.sent();
                         return [2 /*return*/, buffer ? buffer.toString() : ''];
                     case 2:
-                        error_12 = _a.sent();
+                        error_11 = _a.sent();
                         return [2 /*return*/, ''];
                     case 3: return [2 /*return*/];
                 }
@@ -862,7 +768,7 @@ var WebUSBDevice = /** @class */ (function () {
     };
     WebUSBDevice.prototype._releaseInterface = function (interfaceNumber) {
         return __awaiter(this, void 0, void 0, function () {
-            var iface, iface_3, release, error_13;
+            var iface, iface_3, release, error_12;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
@@ -889,8 +795,8 @@ var WebUSBDevice = /** @class */ (function () {
                         _a.sent();
                         return [3 /*break*/, 4];
                     case 3:
-                        error_13 = _a.sent();
-                        throw new Error("releaseInterface error: " + error_13);
+                        error_12 = _a.sent();
+                        throw new Error("releaseInterface error: " + error_12);
                     case 4: return [2 /*return*/];
                 }
             });