WebHID API

WebIDL[SecureContext] partial interface Navigator {
    [SameObject] readonly attribute HID hid;
};

WebIDL[Exposed=(DedicatedWorker,ServiceWorker), SecureContext]
partial interface WorkerNavigator {
    [SameObject] readonly attribute HID hid;
};

WebIDL[Exposed=(DedicatedWorker,ServiceWorker,Window), SecureContext]
interface HID : EventTarget {
    attribute EventHandler onconnect;
    attribute EventHandler ondisconnect;
    Promise<sequence<HIDDevice>> getDevices();
    [Exposed=Window] Promise<sequence<HIDDevice>> requestDevice(
        HIDDeviceRequestOptions options);
};

Instances of HID are created with the internal slots described in the following table:

onconnect attribute

onconnect is an event handler IDL attribute for the connect event type.

ondisconnect attribute

ondisconnect is an event handler IDL attribute for the disconnect event type.

When a HID interface becomes available on the system, run the following steps:

1. Let device be a HIDDevice.
2. Set device.[[vendorId]] to the vendor ID of the device that exposes the interface.
3. Set device.[[productId]] to the product ID of the device that exposes the interface.
4. Set device.[[productName]] to the product name of the device that exposes the interface.
5. Set device.[[collections]] to the result of parsing the Report descriptor.
6. Let hid be the result of calling device's relevant global object's Navigator object's hid getter if device's relevant global object is a Window object, otherwise be the result of calling device's relevant global object's WorkerNavigator object's hid getter.
7. Append device to hid.[[devices]].
8. If the user has allowed the site to access device as the result of a previous call to requestDevice(), then queue a global task on the relevant global object of hid using the HID device task source to fire an event named connect at hid using HIDConnectionEvent with its device attribute initialized to device.

To parse the report descriptor, run the following steps:

1. Let items be the result of converting the report descriptor byte sequence into a list of Main items, Global items, and Local items.
2. Initialize collections to be an empty sequence of HIDCollectionInfo.
3. Initialize ancestors to be an empty list.
4. Initialize localState to be an empty ordered map.
5. Initialize usages to be an empty sequence of unsigned long.
6. Initialize stringIndices to be an empty list.
7. Initialize globalStack to be an empty stack.
8. Initialize initialGlobalState to be an empty ordered map.
9. Initialize reportId to 0.
10. Set initialGlobalState["unitSystem"] to "none".
11. Set initialGlobalState["unitExponent"] to 0.
12. Set initialGlobalState["unitFactorLengthExponent"] to 0.
13. Set initialGlobalState["unitFactorMassExponent"] to 0.
14. Set initialGlobalState["unitFactorTimeExponent"] to 0.
15. Set initialGlobalState["unitFactorTemperatureExponent"] to 0.
16. Set initialGlobalState["unitFactorCurrentExponent"] to 0.
17. Set initialGlobalState["unitFactorLuminousIntensityExponent"] to 0.
18. Set initialGlobalState["logicalMinimum"] to 0.
19. Set initialGlobalState["logicalMaximum"] to 0.
20. Set initialGlobalState["physicalMinimum"] to 0.
21. Set initialGlobalState["physicalMaximum"] to 0.
22. Push initialGlobalState onto globalStack.
23. For each item of items:
    Note

    Main items are described in [USBIF-HID-CLASS] sections 6.2.2.4 through 6.2.2.6. An item with the Input tag, Output tag, or Feature tag defines a field within an input, output, or feature report. The item data field of a Main item with an Input tag, Output tag, or Feature tag is a bit field containing several boolean parameters describing the data field. An item with the Collection tag defines a new collection nested within the current collection, or a new top-level collection if there is no current collection. The item data field of a Main item with a Collection tag contains the collection type. An item with the End Collection tag closes the current collection.

    • If item is a Main item:
      1. If item has the Input tag, Output tag, or Feature tag:
         1. Let globalState be the last item of globalStack.
         2. Let reportId be globalState["reportId"].
         3. Let reportItem be the result of creating a HID report item with item, localState, globalState, usages, and strings.
         4. For each collection of ancestors:
            1. Let reports be:
               • collection["inputReports"] if item has the Input tag,
               • collection["outputReports"] if item has the Output tag, or
               • collection["featureReports"] if item has the Feature tag.

            2. If reports contains an item with its reportId attribute equal to reportId, then let report be that item.

               Otherwise:

               1. Let report be a new HIDReportInfo dictionary.
               2. Set report["reportId"] to reportId.
               3. Set report["items"] to an empty sequence of HIDReportItem.
               4. Append report to reports.
            3. Append item to report["items"].
      2. If item has the Collection tag:
         1. Let collection be a new HIDCollectionInfo dictionary.
         2. Let usage be the first item of usages.
         3. If the size of usages is greater than 1, remove the first item of usages.
         4. Set collection["usagePage"] to globalState["usagePage"].
         5. Set collection["usage"] to usage.
         6. Set collection["type"] to the value representing the collection's type.
         7. Set collection["children"] to an empty sequence of HIDCollectionInfo.
         8. Set collection["inputReports"] to an empty sequence of HIDReportInfo.
         9. Set collection["outputReports"] to an empty sequence of HIDReportInfo.
         10. Set collection["featureReports"] to an empty sequence of HIDReportInfo.

         11. If ancestors is empty, append collection to collections.

             Otherwise:

             1. Let parent be the last item of ancestors.
             2. Append collection to parent["children"].
         12. Append collection to ancestors.
      3. If item has the End Collection tag, then remove the last item of ancestors.
      4. Set localState to be an empty ordered map.
      5. Set usages to be an empty sequence of unsigned long.
         Note

         Global items are described in section 6.2.2.7. An item with the Usage Page tag, Logical Minimum tag, Logical Maximum tag, Physical Minimum tag, Physical Maximum tag, Unit Exponent tag, Unit tag, Report Size tag, Report ID tag, or Report Count tag modifies the respective field of the global item state table. An item with the Push tag pushes a copy of the current global item state table onto the item state stack. An item with the Pop tag replaces the global item state table with the top of the item state stack. The global Report ID value is not affected when manipulating the item state stack.

      6. If item is a Global item:
         1. Let globalState be the last item of globalStack.
         2. Let value be the item data field interpreted as an unsigned long.
         3. If item has the Usage Page tag, then set globalState["usagePage"] to value.
         4. If item has the Logical Minimum tag, then set globalState["logicalMinimum"] to value.
         5. If item has the Logical Maximum tag, then set globalState["logicalMaximum"] to value.
         6. If item has the Physical Minimum tag, then set globalState["physicalMinimum"] to value.
         7. If item has the Physical Maximum tag, then set globalState["physicalMaximum"] to value.
         8. If item has the Report Size tag, then set globalState["reportSize"] to value.
         9. If item has the Report ID tag, then set globalState["reportId"] to value.
         10. If item has the Report Count tag, then set globalState["reportCount"] to value.
         11. If item has the Unit tag:
             1. Let nibbles be the result of interpreting value as a sequence of eight 4-bit signed two's complement integers starting from the low-order bits.
             2. If nibbles[0] is:
                • 0, then set globalState["unitSystem"] to "none"
                • 1, then set globalState["unitSystem"] to "si-linear"
                • 2, then set globalState["unitSystem"] to "si-rotation"
                • 3, then set globalState["unitSystem"] to "english-linear"
                • 4, then set globalState["unitSystem"] to "english-rotation"
                • -1, then set globalState["unitSystem"] to "vendor-defined"
                • Otherwise, set globalState["unitSystem"] to "reserved"
             3. Set globalState["unitFactorLengthExponent"] to nibbles[1].
             4. Set globalState["unitFactorMassExponent"] to nibbles[2].
             5. Set globalState["unitFactorTimeExponent"] to nibbles[3].
             6. Set globalState["unitFactorTemperatureExponent"] to nibbles[4].
             7. Set globalState["unitFactorCurrentExponent"] to nibbles[5].
             8. Set globalState["unitFactorLuminousIntensityExponent"] to nibbles[6].
         12. If item has the Unit Exponent tag, then set globalState["unitExponent"] to the result of interpreting the lowest 4 bits of the item data field as a signed two's complement integer.
         13. If item has the Push tag, then push a copy of globalState onto globalStack.
         14. If item has the Pop tag, then pop from globalStack.
      Note

      Local items are described in section 6.2.2.8. An item with the Usage tag, Usage Minimum tag, Usage Maximum tag, String Index tag, String Minimum tag, or String Maximum tag modifies the respective field of the local item state table. The local item state is cleared after each Main item.

    • If item is a Local item:
      1. Let value be the item data field interpreted as an unsigned long.
      2. If item has the Usage tag:
         1. If item's bSize field is 1 or 2:
            1. Let usageId be an unsigned short containing the lower 16 bits of value.
            2. Let globalState be the last item of globalStack.
            3. Set value to a HID usage composed of globalState["usagePage"] in the high order bits and usageId in the low order bits.
         2. Append value to usages.
      3. If item has the Usage Minimum tag, then set localState["usageMinimum"] to value.
      4. If item has the Usage Maximum tag, then set localState["usageMaximum"] to value.
      5. If item has the String Index tag, then append value to stringIndices.
      6. If item has the String Minimum tag, then set localState["stringMinimum"] to value.
      7. If item has the String Maximum tag, then set localState["stringMaximum"] to value.

To create a HID report item with item, localState, globalState, usages, and stringIndices, run the following steps:

1. Let reportItem be a new HIDReportItem dictionary.
2. Let value be the item data field interpreted as an unsigned long.
3. Let bitfield be a list of boolean values representing each of the bits of value, starting from the low-order bits.
4. Set reportItem["isConstant"] to bitfield[0].
5. Set reportItem["isArray"] to !bitfield[1].
6. Set reportItem["isAbsolute"] to !bitfield[2].
7. Set reportItem["wrap"] to bitfield[3].
8. Set reportItem["isLinear"] to !bitfield[4].
9. Set reportItem["hasPreferredState"] to bitfield[5].
10. Set reportItem["hasNull"] to bitfield[6].
11. Set reportItem["isVolatile"] to bitfield[7].
12. Set reportItem["isBufferedBytes"] to bitfield[8].
13. Set reportItem["usages"] to usages.
14. Set reportItem["reportSize"] to globalState["reportSize"].
15. Set reportItem["reportCount"] to globalState["reportCount"].
16. Set reportItem["unitExponent"] to globalState["unitExponent"].
17. Set reportItem["unitSystem"] to globalState["unitSystem"].
18. Set reportItem["unitFactorLengthExponent"] to globalState["unitFactorLengthExponent"].
19. Set reportItem["unitFactorMassExponent"] to globalState["unitFactorMassExponent"].
20. Set reportItem["unitFactorTimeExponent"] to globalState["unitFactorTimeExponent"].
21. Set reportItem["unitFactorTemperatureExponent"] to globalState["unitFactorTemperatureExponent"].
22. Set reportItem["unitFactorCurrentExponent"] to globalState["unitFactorCurrentExponent"].
23. Set reportItem["unitFactorLuminousIntensityExponent"] to globalState["unitFactorLuminousIntensityExponent"].
24. Set reportItem["logicalMinimum"] to globalState["logicalMinimum"].
25. Set reportItem["logicalMaximum"] to globalState["logicalMaximum"].
26. Set reportItem["physicalMinimum"] to globalState["physicalMinimum"].
27. Set reportItem["physicalMaximum"] to globalState["physicalMaximum"].

28. If "usageMinimum" is in localState, then set reportItem["usageMinimum"] to localState["usageMinimum"].

29. If "usageMaximum" is in localState, then set reportItem["usageMaximum"] to localState["usageMaximum"].

30. Set reportItem["isRange"] to true if reportItem["usageMinimum"] is less than reportItem["usageMaximum"], or false otherwise.
31. If "stringMinimum" is in localState and "stringMaximum" is in localState:
    1. Append the items of the range from localState["stringMinimum"] to localState["stringMaximum"] to stringIndices.
32. For each stringIndex of stringIndices:
    1. Let string be the result of reading the string descriptor at index stringIndex.
    2. Append string to reportItem["strings"].
33. Return reportItem.

When a HID interface becomes unavailable on the system, run the following steps:

1. Let device be the HIDDevice in hid.[[devices]] representing the interface.
2. Let hid be the result of calling device's relevant global object's Navigator object's hid getter if device's relevant global object is a Window object, otherwise be the result of calling device's relevant global object's WorkerNavigator object's hid getter.
3. Remove device from hid.[[devices]].
4. If the user has allowed the site to access device as the result of a previous call to requestDevice(), then queue a global task on the relevant global object of hid using the HID device task source to fire an event named disconnect at hid using HIDConnectionEvent with its device attribute initialized to device.

WebIDLdictionary HIDDeviceRequestOptions {
    required sequence<HIDDeviceFilter> filters;
    sequence<HIDDeviceFilter> exclusionFilters;
};

WebIDLdictionary HIDDeviceFilter {
    unsigned long vendorId;
    unsigned short productId;
    unsigned short usagePage;
    unsigned short usage;
};

WebIDL[Exposed=(DedicatedWorker,ServiceWorker,Window), SecureContext]
interface HIDDevice : EventTarget {
    attribute EventHandler oninputreport;
    readonly attribute boolean opened;
    readonly attribute unsigned short vendorId;
    readonly attribute unsigned short productId;
    readonly attribute DOMString productName;
    readonly attribute FrozenArray<HIDCollectionInfo> collections;
    Promise<undefined> open();
    Promise<undefined> close();
    Promise<undefined> forget();
    Promise<undefined> sendReport([EnforceRange] octet reportId, BufferSource data);
    Promise<undefined> sendFeatureReport(
        [EnforceRange] octet reportId,
        BufferSource data);
    Promise<DataView> receiveFeatureReport([EnforceRange] octet reportId);
};

Methods on this interface typically complete asynchronously, queuing work on the HID device task source.

Instances of HIDDevice are created with the internal slots described in the following table:

oninputreport attribute

oninputreport is an event handler IDL attribute for the inputreport event type.

opened attribute

A flag indicating that the HIDDevice is ready to transfer data.

The opened getter steps are:

1. If this.[[state]] is opened, then return true.
2. Return false.

vendorId attribute

A vendor ID is an unsigned short value assigned by a vendor ID source that identifies the manufacturer of a device.

The vendorId attribute is the vendor ID of the device. If the device has no vendor ID or the vendor ID cannot be accessed, the attribute MUST be 0.

The vendorId getter steps are:

1. Return this.[[vendorId]].

productId attribute

A product ID is an unsigned short value assigned by the manufacturer of the device that identifies the product.

The productId attribute is the product ID of the device. If the device has no product ID or the product ID cannot be accessed, the attribute MUST be 0.

The productId getter steps are:

1. Return this.[[productId]].

productName attribute

A string identifying the product.

For USB HID devices, the product name SHOULD contain the value of the string descriptor at the index iProduct specified in the Device Descriptor. For Bluetooth HID devices, the product name SHOULD contain the value of the Device Name characteristic. If the device has no product name or the product name is empty or cannot be accessed, the attribute MUST return an empty string.

The productName string SHOULD NOT contain any identifiers like a serial number or Bluetooth device address that could be used to uniquely identify the device.

The productName getter steps are:

1. Return this.[[productName]].

collections attribute

A sequence of HIDCollectionInfo representing the top-level collections in the report descriptor.

The collections getter steps are:

1. Return this.[[collections]].

Note

Top-level collections group items that serve similar purposes within the device. Applications look at the HID usage applied to top-level collections to identify devices. An application may not recognize a device if it does not follow the conventions for a particular type of device. Refer to [USBIF-HID-USAGE] for more information about the conventional behavior for standard HID devices.

When an input report is received from a device, run the following steps:

1. If the input report is a blocked report, abort these steps.
2. Let reportId be the report ID for this report, or 0 if the HID interface does not use report IDs.
3. Let data be a DataView created over the byte sequence representing the input report. If the HID interface uses report IDs, the byte sequence MUST NOT include the report ID byte.
4. Queue a global task on the relevant global object of this using the HID device task source to fire an event named inputreport at device using HIDInputReportEvent with its device attribute initialized to device, its reportId attribute initialized to reportId, and its data attribute initialized to data.

WebIDL[Exposed=(DedicatedWorker,ServiceWorker,Window), SecureContext]
interface HIDConnectionEvent : Event {
    constructor(DOMString type, HIDConnectionEventInit eventInitDict);
    [SameObject] readonly attribute HIDDevice device;
};

device attribute

The HIDDevice instance that represents the connected or disconnected device.

WebIDLdictionary HIDConnectionEventInit : EventInit {
    required HIDDevice device;
};

WebIDL[Exposed=(DedicatedWorker,ServiceWorker,Window), SecureContext]
interface HIDInputReportEvent : Event {
    constructor(DOMString type, HIDInputReportEventInit eventInitDict);
    [SameObject] readonly attribute HIDDevice device;
    readonly attribute octet reportId;
    readonly attribute DataView data;
};

device attribute

The HIDDevice instance that represents the HID interface that sent the input report.

reportId attribute

The one-byte identification prefix for this report, or 0 if the HID interface does not use report IDs.

data attribute

A DataView containing the data from the input report, excluding the reportId byte if the HID interface uses report IDs.

WebIDLdictionary HIDInputReportEventInit : EventInit {
    required HIDDevice device;
    required octet reportId;
    required DataView data;
};

WebIDLdictionary HIDCollectionInfo {
    unsigned short usagePage;
    unsigned short usage;
    octet type;
    sequence<HIDCollectionInfo> children;
    sequence<HIDReportInfo> inputReports;
    sequence<HIDReportInfo> outputReports;
    sequence<HIDReportInfo> featureReports;
};

When a device is first connected to the system, the system MUST retrieve the report descriptor for each HID interface exposed by the device. The Report descriptor is a byte sequence that can be expanded into a hierarchical data structure describing the layout of each report supported by the device. The elements of this data structure are called items. Groups of items that share a relationship are called collections.

A HIDCollectionInfo object represents a single collection within the report descriptor. When a collection contains nested collections, the nested collections are included as elements of children.

The inputReports, outputReports, and featureReports attributes contain sequences of HIDReportInfo that give information about each report described within this collection. For a top-level collection, the HIDReportInfo represents a flattened view of all items that compose the report. The flattened view interleaves items contained in nested collections with items contained within the top-level collection. For a nested collection, the HIDReportInfo includes only the items contained within the collection and its nested collections.

usagePage member

The usage page component of the HID usage associated with this collection.

HID usages are constants that can be interpreted by an application to identify the purpose and meaning of an item or collection. A HID usage is an unsigned long value composed of an unsigned short usage page in the high order bits and an unsigned short usage ID in the low order bits. Standard HID usage values are described in [USBIF-HID-CLASS] and other documents published by the USB Implementers Forum.

The HID usages of the top-level collections exposed by the device is used to identify the general device type.

usage member

The usage ID component of the HID usage associated with this collection.

A usage ID is used to select an individual HID usage on a usage page. By convention, usage IDs 0x01 through 0x1F are reserved for top-level collections.

type member

A value representing the collection type.

Collection type	Value
Physical	0x00
Application	0x01
Logical	0x02
Report	0x03
Named Array	0x04
Usage Switch	0x05
Usage Modified	0x06
Reserved for future use	0x07 to 0x7F
Vendor-defined	0x80 to 0xFF

Each collection type describes a different type of relationship among the grouped items. Refer to [USBIF-HID-CLASS] section 6.2.2.6 for more information about collection types.

children member

A sequence of HIDCollectionInfo representing the collections nested within this collection.

inputReports member

A sequence of HIDReportInfo representing the input reports described within this collection.

outputReports member

A sequence of HIDReportInfo representing the output reports described within this collection.

featureReports member

A sequence of HIDReportInfo representing the feature reports described within this collection.

WebIDLdictionary HIDReportInfo {
    octet reportId;
    sequence<HIDReportItem> items;
};

A HIDReportInfo represents one input, output, or feature report within the report descriptor.

reportId member

A HID interface uses report IDs if it prepends a one-byte identification prefix to each report transfer. The reportId member is the prefix for this report if the interface uses report IDs, or 0 otherwise.

items member

A sequence of HIDReportItem representing the fields of this report.

WebIDLdictionary HIDReportItem {
    boolean isAbsolute;
    boolean isArray;
    boolean isBufferedBytes;
    boolean isConstant;
    boolean isLinear;
    boolean isRange;
    boolean isVolatile;
    boolean hasNull;
    boolean hasPreferredState;
    boolean wrap;
    sequence<unsigned long> usages;
    unsigned long usageMinimum;
    unsigned long usageMaximum;
    unsigned short reportSize;
    unsigned short reportCount;
    byte unitExponent;
    HIDUnitSystem unitSystem;
    byte unitFactorLengthExponent;
    byte unitFactorMassExponent;
    byte unitFactorTimeExponent;
    byte unitFactorTemperatureExponent;
    byte unitFactorCurrentExponent;
    byte unitFactorLuminousIntensityExponent;
    long logicalMinimum;
    long logicalMaximum;
    long physicalMinimum;
    long physicalMaximum;
    sequence<DOMString> strings;
};

isAbsolute member

true if the data is absolute (based on a fixed origin), or false if the data is relative (indicating the change in value from the last report).

isArray member

true if the item creates array data fields in reports where each data field contains an index corresponding to a pressed button or key, or false if the item creates variable data fields in reports where each data field contains a value.

isBufferedBytes member

true if the item emits a fixed-sized stream of bytes, or false if the item is a numeric quantity.

isConstant member

true if the item is a static read-only field and cannot be modified, or false if the item defines report fields that contain modifiable device data.

isLinear member

true if the item represents a linear relationship between what is measured and what is reported, or false if the data has been processed in some way.

isRange member

true if the item assigns usages from a HID usage range defined by usageMinimum and usageMaximum, or false if the item has a sequence of HID usage values in usages.

isVolatile member

true if the item value can change without host interaction, or false if the item value should only be changed by the host.

Only used for Feature and Output items.

hasNull member

true if the item has a null state in which it is not sending meaningful data, or false if it does not have a null state. When in a null state, the item will report a value outside of the specified logicalMinimum and logicalMaximum.

hasPreferredState member

true if the item has a preferred state to which it will return when the user is not physically interacting with the control, or false if the item does not have a preferred state.

wrap member

true if the item value rolls over when reaching either the extreme high or low value, or false if the item value does not roll over.

usages member

If isRange is true or this item has no associated HID usage values, then usages MUST be undefined.

If isRange is false then usages is a sequence of HID usage values associated with this item.

usageMinimum member

If isRange is true then usageMinimum contains the minimum HID usage value in the usage range associated with this item.

If isRange is false then usageMinimum MUST be undefined.

usageMaximum member

If isRange is true then usageMaximum contains the maximum HID usage value in the usage range associated with this item.

If isRange is false then usageMaximum MUST be undefined.

reportSize member

The size of each report data field in bits. The reportSize MUST be greater than 0.

reportCount member

The number of fields included in the report for this item. The reportCount MUST be greater than 0.

unitExponent member

The value of the unit exponent, or 0 if the item has no unit definition.

unitSystem member

A HIDUnitSystem enum value specifying the unit system for the unit definition, or "none" if the item has no unit definition.

unitFactorLengthExponent member

The value of the exponent for the length unit (centimeters, radians, inch, or degrees) in the unit definition, or 0 if the item has no unit definition.

unitFactorMassExponent member

The value of the exponent for the mass unit (gram or slug) in the unit definition, or 0 if the item has no unit definition.

unitFactorTimeExponent member

The value of the exponent for the time unit (seconds) in the unit definition, or 0 if the item has no unit definition.

unitFactorTemperatureExponent member

The value of the exponent for the temperature unit (Kelvin or degrees Fahrenheit) in the unit definition, or 0 if the item has no unit definition.

unitFactorCurrentExponent member

The value of the exponent for the electrical current unit (Ampere) in the unit definition, or 0 if the item has no unit definition.

unitFactorLuminousIntensityExponent member

The value of the exponent for the luminous intensity unit (Candela) in the unit definition, or 0 if the item has no unit definition.

logicalMinimum member

The minimum extent of this item in logical units. This is the minimum value that a variable or array item will report.

logicalMaximum member

The maximum extent of this item in logical units. This is the maximum value that a variable or array item wll report.

physicalMinimum member

The minimum value for the physical extent of this item. This represents the logicalMinimum with units applied to it.

physicalMaximum member

The maximum value for the physical extent of this item. This represents the logicalMaximum with units applied to it.

strings member

The strings associated with this item, or an empty sequence if no strings are associated with this item.

[USBIF-HID-CLASS] section 6.2.2.7 defines four standard unit systems: SI Linear, SI Rotation, English Linear, and English Rotation. Each item uses one of these four unit systems, a vendor-defined unit system, or no unit system.

WebIDLenum HIDUnitSystem {
    "none", "si-linear", "si-rotation", "english-linear",
    "english-rotation", "vendor-defined", "reserved"
};

"none"

No unit system. Indicates that the item does not have a unit definition.

"si-linear"

The SI Linear unit system uses centimeter, gram, second, Kelvin, Ampere, Candela.

"si-rotation"

The SI Rotation unit system uses radian, gram, second, Kelvin, Ampere, Candela.

"english-linear"

The English Linear unit system uses inch, slug, second, degree Fahrenheit, Ampere, Candela.

"english-rotation"

The English Rotation unit system uses degree, slug, second, degree Fahrenheit, Ampere, Candela.

"vendor-defined"

A vendor-defined unit system.

"reserved"

Indicates that the device used a reserved value for its unit system.

This specification relies on a blocklist file in the https://github.com/WICG/webhid repository to restrict the set of HID devices a website can access.

The result of parsing the blocklist at a URL url is a sequence of dictionary objects produced by fetching url and parsing its contents as JSON.

The HID blocklist is the result of parsing the blocklist at https://github.com/WICG/webhid/blob/main/blocklist.txt

A report is a blocked report if the following steps return true:

1. For each rule of the HID blocklist:
   1. If the report is blocked by a blocklist rule rule then return true.
2. Return false.

A report is blocked by a blocklist rule rule if the following steps return true:

1. Let reportId be the report ID of the report, or 0 if the HID interface does not use report IDs.
2. Let reportType be "input" if the report is an input report, "output" if the report is an output report, or "feature" if the report is a feature report.
3. Let collection be the top-level collection that contains the report.
4. If rule contains "vendor" and rule["vendor"] is not device.vendorId, return false.
5. If rule contains "product" and rule["product"] is not device.productId, return false.
6. If rule contains "reportId" and rule["reportId"] is not reportId, return false.
7. If rule contains "reportType" and rule["reportType"] is not reportType, return false.
8. If rule contains "usagePage" and rule["usagePage"] is not collection["usagePage"], return false.
9. If rule contains "usage" and rule.["usage"] is not collection["usage"], return false.
10. Return true.

As well as sections marked as non-normative, all authoring guidelines, diagrams, examples, and notes in this specification are non-normative. Everything else in this specification is normative.

The key words MAY, MUST, MUST NOT, SHOULD, and SHOULD NOT in this document are to be interpreted as described in BCP 14 [RFC2119] [RFC8174] when, and only when, they appear in all capitals, as shown here.