@yume-chan/adb-daemon-webusb 0.0.20

package/CHANGELOG.json

@@ -0,0 +1,157 @@
+{
+  "name": "@yume-chan/adb-daemon-webusb",
+  "entries": [
+    {
+      "version": "0.0.20",
+      "tag": "@yume-chan/adb-daemon-webusb_v0.0.20",
+      "date": "Mon, 05 Jun 2023 02:51:41 GMT",
+      "comments": {
+        "none": [
+          {
+            "comment": "Use ECMAScript private class fields syntax (supported by Chrome 74, Firefox 90, Safari 14.1 and Node.js 12.0.0)."
+          },
+          {
+            "comment": "Rename package to `@yume-chan/adb-daemon-webusb` following the renaming of `AdbDaemonTransport`."
+          },
+          {
+            "comment": "Rename `AdbWebUsbBackend` to `AdbDaemonWebUsbDevice` following the renaming of `AdbDaemonTransport`."
+          },
+          {
+            "comment": "Add Support for detecting device disconnects. It no longer throws an `NetworkError` when the device is disconnected."
+          },
+          {
+            "comment": "Add `filters` parameter to `AdbDaemonWebUsbDeviceManager#getDevices`. The filtration is manually implemented because WebUSB's `getDevice` API doesn't support filters."
+          }
+        ]
+      }
+    },
+    {
+      "version": "0.0.19",
+      "tag": "@yume-chan/adb-daemon-webusb_v0.0.19",
+      "date": "Sun, 09 Apr 2023 05:55:33 GMT",
+      "comments": {
+        "none": [
+          {
+            "comment": "Remove stream queuing"
+          },
+          {
+            "comment": "Add the `AdbWebUsbBackendManager` class to simplify the usage with custom WebUSB implementations (for example the `usb` NPM package)."
+          }
+        ]
+      }
+    },
+    {
+      "version": "0.0.18",
+      "tag": "@yume-chan/adb-daemon-webusb_v0.0.18",
+      "date": "Wed, 25 Jan 2023 21:33:49 GMT",
+      "comments": {
+        "none": [
+          {
+            "comment": "Add an option to specify USB filters"
+          }
+        ]
+      }
+    },
+    {
+      "version": "0.0.17",
+      "tag": "@yume-chan/adb-daemon-webusb_v0.0.17",
+      "date": "Tue, 18 Oct 2022 09:32:30 GMT",
+      "comments": {
+        "none": [
+          {
+            "comment": "Update to use new stream util package"
+          }
+        ]
+      }
+    },
+    {
+      "version": "0.0.16",
+      "tag": "@yume-chan/adb-daemon-webusb_v0.0.16",
+      "date": "Sat, 28 May 2022 03:56:37 GMT",
+      "comments": {
+        "none": [
+          {
+            "comment": "Upgrade TypeScript to 4.7.2 to enable Node.js ESM"
+          }
+        ]
+      }
+    },
+    {
+      "version": "0.0.15",
+      "tag": "@yume-chan/adb-daemon-webusb_v0.0.15",
+      "date": "Mon, 02 May 2022 04:18:01 GMT",
+      "comments": {
+        "none": [
+          {
+            "comment": "Improve connection lifecycle handling"
+          }
+        ]
+      }
+    },
+    {
+      "version": "0.0.14",
+      "tag": "@yume-chan/adb-daemon-webusb_v0.0.14",
+      "date": "Sat, 30 Apr 2022 14:05:48 GMT",
+      "comments": {}
+    },
+    {
+      "version": "0.0.13",
+      "tag": "@yume-chan/adb-daemon-webusb_v0.0.13",
+      "date": "Thu, 28 Apr 2022 01:23:53 GMT",
+      "comments": {
+        "none": [
+          {
+            "comment": "Workaround an issue in Chrome where `transferIn` never returns `babble` on Windows"
+          }
+        ]
+      }
+    },
+    {
+      "version": "0.0.12",
+      "tag": "@yume-chan/adb-daemon-webusb_v0.0.12",
+      "date": "Sun, 03 Apr 2022 11:18:47 GMT",
+      "comments": {}
+    },
+    {
+      "version": "0.0.11",
+      "tag": "@yume-chan/adb-daemon-webusb_v0.0.11",
+      "date": "Sun, 03 Apr 2022 10:54:15 GMT",
+      "comments": {
+        "none": [
+          {
+            "comment": "Update to use Web Streams API"
+          },
+          {
+            "comment": "Improve compatibility with Node.js 12 ESM format"
+          },
+          {
+            "comment": "Update license year"
+          }
+        ],
+        "dependency": [
+          {
+            "comment": "Updating dependency \"@yume-chan/adb\" from `^0.0.10` to `^0.0.11`"
+          }
+        ]
+      }
+    },
+    {
+      "version": "0.0.10",
+      "tag": "@yume-chan/adb-daemon-webusb_v0.0.10",
+      "date": "Sun, 09 Jan 2022 15:52:20 GMT",
+      "comments": {
+        "none": [
+          {
+            "comment": "Remove `encodeUtf8()` and `decodeUtf8()` from `AdbBackend`"
+          }
+        ]
+      }
+    },
+    {
+      "version": "0.0.9",
+      "tag": "@yume-chan/adb-daemon-webusb_v0.0.9",
+      "date": "Sun, 09 Jan 2022 15:50:20 GMT",
+      "comments": {}
+    }
+  ]
+}

package/CHANGELOG.md

@@ -0,0 +1,89 @@
+# Change Log - @yume-chan/adb-daemon-webusb
+
+This log was last generated on Mon, 05 Jun 2023 02:51:41 GMT and should not be manually modified.
+
+## 0.0.20
+Mon, 05 Jun 2023 02:51:41 GMT
+
+### Updates
+
+- Use ECMAScript private class fields syntax (supported by Chrome 74, Firefox 90, Safari 14.1 and Node.js 12.0.0).
+- Rename package to `@yume-chan/adb-daemon-webusb` following the renaming of `AdbDaemonTransport`.
+- Rename `AdbWebUsbBackend` to `AdbDaemonWebUsbDevice` following the renaming of `AdbDaemonTransport`.
+- Add Support for detecting device disconnects. It no longer throws an `NetworkError` when the device is disconnected.
+- Add `filters` parameter to `AdbDaemonWebUsbDeviceManager#getDevices`. The filtration is manually implemented because WebUSB's `getDevice` API doesn't support filters.
+
+## 0.0.19
+Sun, 09 Apr 2023 05:55:33 GMT
+
+### Updates
+
+- Remove stream queuing
+- Add the `AdbWebUsbBackendManager` class to simplify the usage with custom WebUSB implementations (for example the `usb` NPM package).
+
+## 0.0.18
+Wed, 25 Jan 2023 21:33:49 GMT
+
+### Updates
+
+- Add an option to specify USB filters
+
+## 0.0.17
+Tue, 18 Oct 2022 09:32:30 GMT
+
+### Updates
+
+- Update to use new stream util package
+
+## 0.0.16
+Sat, 28 May 2022 03:56:37 GMT
+
+### Updates
+
+- Upgrade TypeScript to 4.7.2 to enable Node.js ESM
+
+## 0.0.15
+Mon, 02 May 2022 04:18:01 GMT
+
+### Updates
+
+- Improve connection lifecycle handling
+
+## 0.0.14
+Sat, 30 Apr 2022 14:05:48 GMT
+
+_Version update only_
+
+## 0.0.13
+Thu, 28 Apr 2022 01:23:53 GMT
+
+### Updates
+
+- Workaround an issue in Chrome where `transferIn` never returns `babble` on Windows
+
+## 0.0.12
+Sun, 03 Apr 2022 11:18:47 GMT
+
+_Version update only_
+
+## 0.0.11
+Sun, 03 Apr 2022 10:54:15 GMT
+
+### Updates
+
+- Update to use Web Streams API
+- Improve compatibility with Node.js 12 ESM format
+- Update license year
+
+## 0.0.10
+Sun, 09 Jan 2022 15:52:20 GMT
+
+### Updates
+
+- Remove `encodeUtf8()` and `decodeUtf8()` from `AdbBackend`
+
+## 0.0.9
+Sun, 09 Jan 2022 15:50:20 GMT
+
+_Initial release_
+

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020-2023 Simon Chan
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,130 @@
+# @yume-chan/adb-daemon-webusb
+
+ADB daemon transport device for `@yume-chan/adb` using WebUSB ([MDN](https://developer.mozilla.org/en-US/docs/Web/API/USB), [Spec](https://wicg.github.io/webusb)) API.
+
+-   [Use in browser](#use-in-browser)
+-   [Use in Node.js](#use-in-nodejs)
+-   [`AdbDaemonWebUsbDevice`](#adbdaemonwebusbdevice)
+    -   [constructor](#constructor)
+    -   [`raw`](#raw)
+    -   [`connect`](#connect)
+-   [`AdbDaemonWebUsbDeviceManager`](#adbdaemonwebusbdevicemanager)
+    -   [`BROWSER`](#browser)
+    -   [constructor](#constructor-1)
+    -   [`requestDevice`](#requestdevice)
+    -   [`getDevices`](#getdevices)
+-   [Note on secure context](#note-on-secure-context)
+
+## Use in browser
+
+| Chrome         | Edge           | Firefox | Internet Explorer | Safari |
+| -------------- | -------------- | ------- | ----------------- | ------ |
+| 61<sup>1</sup> | 79<sup>1</sup> | No      | No                | No     |
+
+<sup>1</sup>: Chrome for Android is supported, Chrome for iOS is NOT supported.
+
+## Use in Node.js
+
+| Node.js | `usb` NPM Package |
+| ------- | ----------------- |
+| 10.5    | 2.8.1             |
+
+Node.js doesn't have native support for WebUSB API, but the [`usb`](https://www.npmjs.com/package/usb) NPM package provides a WebUSB compatible API.
+
+To use a custom WebUSB API implementation, pass it to the constructor of `AdbDaemonWebUsbDevice`, `AdbDaemonWebUsbDeviceManager` and `AdbDaemonWebUsbConnectionWatcher` via the `usbManager` parameter.
+
+## `AdbDaemonWebUsbDevice`
+
+### constructor
+
+```ts
+public constructor(
+    device: USBDevice,
+    filters: AdbDeviceFilter[] = [ADB_DEFAULT_DEVICE_FILTER]
+    usbManager: USB
+);
+```
+
+Create a new instance of `AdbDaemonWebUsbDevice` using a specified `USBDevice` instance.
+
+`USBDevice` and `USB` types are from WebUSB API.
+
+The `filters` parameter specifies the `classCode`, `subclassCode` and `protocolCode` to use when searching for ADB interface. The default value is `[{ classCode: 0xff, subclassCode: 0x42, protocolCode: 0x1 }]`, defined by Google.
+
+### `raw`
+
+```ts
+public get raw(): USBDevice;
+```
+
+Gets the raw `USBDevice` from the device. Allow sending/receiving USB packets to other interfaces/endpoints. For example can be used with `@yume-chan/aoa` package.
+
+### `connect`
+
+```ts
+public async connect(): Promise<
+    ReadableWritablePair<AdbPacketData, Consumable<AdbPacketInit>>
+>
+```
+
+Claim the device and create a pair of `AdbPacket` streams to the ADB interface.
+
+## `AdbDaemonWebUsbDeviceManager`
+
+A helper class that wraps the WebUSB API.
+
+### `BROWSER`
+
+```ts
+public static readonly BROWSER: AdbDaemonWebUsbDeviceManager | undefined;
+```
+
+Gets the instance of `AdbDaemonWebUsbDeviceManager` using browser WebUSB implementation.
+
+May be `undefined` if the browser does not support WebUSB.
+
+### constructor
+
+```ts
+public constructor(usbManager: USB);
+```
+
+Create a new instance of `AdbDaemonWebUsbDeviceManager` using the specified WebUSB API implementation.
+
+### `requestDevice`
+
+```ts
+public async requestDevice(
+    filters: AdbDeviceFilter[] = [ADB_DEFAULT_DEVICE_FILTER]
+): Promise<AdbDaemonWebUsbDevice | undefined>
+```
+
+Request access to a connected device.
+This is a convince method for `usb.requestDevice()`.
+
+The `filters` parameter must have `classCode`, `subclassCode` and `protocolCode` fields for selecting the ADB interface. It can also have `vendorId`, `productId` or `serialNumber` fields to limit the displayed device list.
+
+Returns an `AdbDaemonWebUsbDevice` instance, or `undefined` if the user cancelled the picker.
+
+### `getDevices`
+
+```ts
+public async getDevices(
+    filters: AdbDeviceFilter[] = [ADB_DEFAULT_DEVICE_FILTER]
+): Promise<AdbDaemonWebUsbDevice[]>
+```
+
+Get all connected and authenticated devices.
+
+This is a convince method for `usb.getDevices()`.
+
+## Note on secure context
+
+WebUSB requires a [secure context](https://developer.mozilla.org/en-US/docs/Web/Security/Secure_Contexts) (HTTPS).
+
+`localhost` is considered secure, so local development works. But to access a self-hosted server running on another machine, either add a certificate, or add the domain name to the allowlist on each client machine:
+
+1. Open `chrome://flags/#unsafely-treat-insecure-origin-as-secure`
+2. Add the protocol and domain part of your url (e.g. `http://192.168.0.100:9000`) to the input box
+3. Choose `Enable` from the dropdown menu
+4. Restart browser

package/esm/connection.d.ts

@@ -0,0 +1,49 @@
+/// <reference types="w3c-web-usb" />
+import type { AdbDaemonDevice, AdbPacketData, AdbPacketInit } from "@yume-chan/adb";
+import type { Consumable, ReadableWritablePair, WritableStream } from "@yume-chan/stream-extra";
+import { ReadableStream } from "@yume-chan/stream-extra";
+/**
+ * `classCode`, `subclassCode` and `protocolCode` are required
+ * for selecting correct USB configuration and interface.
+ */
+export type AdbDeviceFilter = USBDeviceFilter & Required<Pick<USBDeviceFilter, "classCode" | "subclassCode" | "protocolCode">>;
+/**
+ * The default filter for ADB devices, as defined by Google.
+ */
+export declare const ADB_DEFAULT_DEVICE_FILTER: {
+    readonly classCode: 255;
+    readonly subclassCode: 66;
+    readonly protocolCode: 1;
+};
+export declare class AdbDaemonWebUsbConnectionStreams implements ReadableWritablePair<AdbPacketData, Consumable<AdbPacketInit>> {
+    #private;
+    get readable(): ReadableStream<AdbPacketData>;
+    get writable(): WritableStream<Consumable<{
+        command: number;
+        arg0: number;
+        arg1: number;
+        checksum: number;
+        magic: number;
+        payload: Uint8Array;
+    }>>;
+    constructor(device: USBDevice, inEndpoint: USBEndpoint, outEndpoint: USBEndpoint, usbManager: USB);
+}
+export declare class AdbDaemonWebUsbConnection implements AdbDaemonDevice {
+    #private;
+    get device(): USBDevice;
+    get serial(): string;
+    get name(): string;
+    /**
+     * Create a new instance of `AdbDaemonWebUsbConnection` using a specified `USBDevice` instance
+     *
+     * @param device The `USBDevice` instance obtained elsewhere.
+     * @param filters The filters to use when searching for ADB interface. Defaults to {@link ADB_DEFAULT_DEVICE_FILTER}.
+     */
+    constructor(device: USBDevice, filters: AdbDeviceFilter[] | undefined, usbManager: USB);
+    /**
+     * Claim the device and create a pair of `AdbPacket` streams to the ADB interface.
+     * @returns The pair of `AdbPacket` streams.
+     */
+    connect(): Promise<ReadableWritablePair<AdbPacketData, Consumable<AdbPacketInit>>>;
+}
+//# sourceMappingURL=connection.d.ts.map

package/esm/connection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"connection.d.ts","sourceRoot":"","sources":["../src/connection.ts"],"names":[],"mappings":";AAAA,OAAO,KAAK,EACR,eAAe,EACf,aAAa,EACb,aAAa,EAChB,MAAM,gBAAgB,CAAC;AAMxB,OAAO,KAAK,EACR,UAAU,EACV,oBAAoB,EACpB,cAAc,EACjB,MAAM,yBAAyB,CAAC;AACjC,OAAO,EAGH,cAAc,EAEjB,MAAM,yBAAyB,CAAC;AAMjC;;;GAGG;AACH,MAAM,MAAM,eAAe,GAAG,eAAe,GACzC,QAAQ,CACJ,IAAI,CAAC,eAAe,EAAE,WAAW,GAAG,cAAc,GAAG,cAAc,CAAC,CACvE,CAAC;AAEN;;GAEG;AACH,eAAO,MAAM,yBAAyB;;;;CAIF,CAAC;AA6FrC,qBAAa,gCACT,YAAW,oBAAoB,CAAC,aAAa,EAAE,UAAU,CAAC,aAAa,CAAC,CAAC;;IAGzE,IAAW,QAAQ,kCAElB;IAGD,IAAW,QAAQ;;;;;;;QAElB;gBAGG,MAAM,EAAE,SAAS,EACjB,UAAU,EAAE,WAAW,EACvB,WAAW,EAAE,WAAW,EACxB,UAAU,EAAE,GAAG;CAiItB;AAED,qBAAa,yBAA0B,YAAW,eAAe;;IAK7D,IAAW,MAAM,cAEhB;IAED,IAAW,MAAM,IAAI,MAAM,CAE1B;IAED,IAAW,IAAI,IAAI,MAAM,CAExB;IAED;;;;;OAKG;gBAEC,MAAM,EAAE,SAAS,EACjB,OAAO,+BAAiD,EACxD,UAAU,EAAE,GAAG;IAOnB;;;OAGG;IACU,OAAO,IAAI,OAAO,CAC3B,oBAAoB,CAAC,aAAa,EAAE,UAAU,CAAC,aAAa,CAAC,CAAC,CACjE;CA0CJ"}

package/esm/connection.js

@@ -0,0 +1,230 @@
+import { AdbPacketHeader, AdbPacketSerializeStream, unreachable, } from "@yume-chan/adb";
+import { ConsumableWritableStream, DuplexStreamFactory, ReadableStream, pipeFrom, } from "@yume-chan/stream-extra";
+import { EMPTY_UINT8_ARRAY } from "@yume-chan/struct";
+import { isErrorName } from "./utils.js";
+/**
+ * The default filter for ADB devices, as defined by Google.
+ */
+export const ADB_DEFAULT_DEVICE_FILTER = {
+    classCode: 0xff,
+    subclassCode: 0x42,
+    protocolCode: 1,
+};
+function alternateMatchesFilter(alternate, filters) {
+    return filters.some((filter) => alternate.interfaceClass === filter.classCode &&
+        alternate.interfaceSubclass === filter.subclassCode &&
+        alternate.interfaceProtocol === filter.protocolCode);
+}
+function findUsbAlternateInterface(device, filters) {
+    for (const configuration of device.configurations) {
+        for (const interface_ of configuration.interfaces) {
+            for (const alternate of interface_.alternates) {
+                if (alternateMatchesFilter(alternate, filters)) {
+                    return { configuration, interface_, alternate };
+                }
+            }
+        }
+    }
+    throw new Error("No matched alternate interface found");
+}
+/**
+ * Find the first pair of input and output endpoints from an alternate interface.
+ *
+ * ADB interface only has two endpoints, one for input and one for output.
+ */
+function findUsbEndpoints(endpoints) {
+    if (endpoints.length === 0) {
+        throw new Error("No endpoints given");
+    }
+    let inEndpoint;
+    let outEndpoint;
+    for (const endpoint of endpoints) {
+        switch (endpoint.direction) {
+            case "in":
+                inEndpoint = endpoint;
+                if (outEndpoint) {
+                    return { inEndpoint, outEndpoint };
+                }
+                break;
+            case "out":
+                outEndpoint = endpoint;
+                if (inEndpoint) {
+                    return { inEndpoint, outEndpoint };
+                }
+                break;
+        }
+    }
+    if (!inEndpoint) {
+        throw new Error("No input endpoint found.");
+    }
+    if (!outEndpoint) {
+        throw new Error("No output endpoint found.");
+    }
+    throw new Error("unreachable");
+}
+class Uint8ArrayExactReadable {
+    #data;
+    #position;
+    get position() {
+        return this.#position;
+    }
+    constructor(data) {
+        this.#data = data;
+        this.#position = 0;
+    }
+    readExactly(length) {
+        const result = this.#data.subarray(this.#position, this.#position + length);
+        this.#position += length;
+        return result;
+    }
+}
+export class AdbDaemonWebUsbConnectionStreams {
+    #readable;
+    get readable() {
+        return this.#readable;
+    }
+    #writable;
+    get writable() {
+        return this.#writable;
+    }
+    constructor(device, inEndpoint, outEndpoint, usbManager) {
+        let closed = false;
+        const duplex = new DuplexStreamFactory({
+            close: async () => {
+                try {
+                    closed = true;
+                    await device.close();
+                }
+                catch {
+                    /* device may have already disconnected */
+                }
+            },
+            dispose: () => {
+                closed = true;
+                usbManager.removeEventListener("disconnect", handleUsbDisconnect);
+            },
+        });
+        function handleUsbDisconnect(e) {
+            if (e.device === device) {
+                duplex.dispose().catch(unreachable);
+            }
+        }
+        usbManager.addEventListener("disconnect", handleUsbDisconnect);
+        this.#readable = duplex.wrapReadable(new ReadableStream({
+            async pull(controller) {
+                try {
+                    // The `length` argument in `transferIn` must not be smaller than what the device sent,
+                    // otherwise it will return `babble` status without any data.
+                    // ADB daemon sends each packet in two parts, the 24-byte header and the payload.
+                    const result = await device.transferIn(inEndpoint.endpointNumber, 24);
+                    // TODO: webusb: handle `babble` by discarding the data and receive again
+                    // Per spec, the `result.data` always covers the whole `buffer`.
+                    const buffer = new Uint8Array(result.data.buffer);
+                    const stream = new Uint8ArrayExactReadable(buffer);
+                    // Add `payload` field to its type, it's assigned below.
+                    const packet = AdbPacketHeader.deserialize(stream);
+                    if (packet.payloadLength !== 0) {
+                        const result = await device.transferIn(inEndpoint.endpointNumber, packet.payloadLength);
+                        packet.payload = new Uint8Array(result.data.buffer);
+                    }
+                    else {
+                        packet.payload = EMPTY_UINT8_ARRAY;
+                    }
+                    controller.enqueue(packet);
+                }
+                catch (e) {
+                    // On Windows, disconnecting the device will cause `NetworkError` to be thrown,
+                    // even before the `disconnect` event is fired.
+                    // We need to wait a little bit and check if the device is still connected.
+                    // https://github.com/WICG/webusb/issues/219
+                    if (isErrorName(e, "NetworkError")) {
+                        await new Promise((resolve) => {
+                            setTimeout(() => {
+                                resolve();
+                            }, 100);
+                        });
+                        if (closed) {
+                            controller.close();
+                        }
+                        else {
+                            throw e;
+                        }
+                    }
+                    throw e;
+                }
+            },
+        }));
+        const zeroMask = outEndpoint.packetSize - 1;
+        this.#writable = pipeFrom(duplex.createWritable(new ConsumableWritableStream({
+            write: async (chunk) => {
+                try {
+                    await device.transferOut(outEndpoint.endpointNumber, chunk);
+                    // In USB protocol, a not-full packet indicates the end of a transfer.
+                    // If the payload size is a multiple of the packet size,
+                    // we need to send an empty packet to indicate the end,
+                    // so the OS will send it to the device immediately.
+                    if (zeroMask &&
+                        (chunk.byteLength & zeroMask) === 0) {
+                        await device.transferOut(outEndpoint.endpointNumber, EMPTY_UINT8_ARRAY);
+                    }
+                }
+                catch (e) {
+                    if (closed) {
+                        return;
+                    }
+                    throw e;
+                }
+            },
+        })), new AdbPacketSerializeStream());
+    }
+}
+export class AdbDaemonWebUsbConnection {
+    #filters;
+    #usbManager;
+    #device;
+    get device() {
+        return this.#device;
+    }
+    get serial() {
+        return this.#device.serialNumber;
+    }
+    get name() {
+        return this.#device.productName;
+    }
+    /**
+     * Create a new instance of `AdbDaemonWebUsbConnection` using a specified `USBDevice` instance
+     *
+     * @param device The `USBDevice` instance obtained elsewhere.
+     * @param filters The filters to use when searching for ADB interface. Defaults to {@link ADB_DEFAULT_DEVICE_FILTER}.
+     */
+    constructor(device, filters = [ADB_DEFAULT_DEVICE_FILTER], usbManager) {
+        this.#device = device;
+        this.#filters = filters;
+        this.#usbManager = usbManager;
+    }
+    /**
+     * Claim the device and create a pair of `AdbPacket` streams to the ADB interface.
+     * @returns The pair of `AdbPacket` streams.
+     */
+    async connect() {
+        if (!this.#device.opened) {
+            await this.#device.open();
+        }
+        const { configuration, interface_, alternate } = findUsbAlternateInterface(this.#device, this.#filters);
+        if (this.#device.configuration?.configurationValue !==
+            configuration.configurationValue) {
+            // Note: Switching configuration is not supported on Windows,
+            // but Android devices should always expose ADB function at the first (default) configuration.
+            await this.#device.selectConfiguration(configuration.configurationValue);
+        }
+        if (!interface_.claimed) {
+            await this.#device.claimInterface(interface_.interfaceNumber);
+        }
+        if (interface_.alternate.alternateSetting !== alternate.alternateSetting) {
+            await this.#device.selectAlternateInterface(interface_.interfaceNumber, alternate.alternateSetting);
+        }
+        const { inEndpoint, outEndpoint } = findUsbEndpoints(alternate.endpoints);
+        return new AdbDaemonWebUsbConnectionStreams(this.#device, inEndpoint, outEndpoint, this.#usbManager);
+    }
+}
+//# sourceMappingURL=connection.js.map