@microbit/microbit-connection 0.9.0-apps.alpha.2 → 0.9.0-apps.alpha.20

package/build/esm/device.d.ts

@@ -3,82 +3,128 @@
  *
  * SPDX-License-Identifier: MIT
  */
-import { TypedEventTarget, ValueIsEvent } from "./events.js";
 /**
- * Specific identified error types.
+ * Connection availability status returned by checkAvailability().
+ * Used for pre-flight UX decisions before attempting to connect.
+ */
+export type ConnectionAvailabilityStatus = "available" | "unsupported" | "disabled" | "permission-denied" | "location-disabled";
+/**
+ * Error codes identifying specific failure modes.
+ *
+ * Each code represents a distinct category of failure that apps can
+ * match on to decide what message to show or what recovery to attempt.
+ * New codes may be added in future minor releases.
  *
- * New members may be added over time.
+ * Codes are annotated with **USB**, **BLE**, or **USB, BLE** to indicate
+ * which connection types can produce them. USB-only apps can ignore
+ * BLE-only codes.
  */
 export type DeviceErrorCode = 
 /**
- * Device not selected, e.g. because the user cancelled the dialog.
+ * **BLE.** The operation was cancelled via an {@link AbortSignal}
+ * supplied by the caller. No user-facing error is needed.
  */
-"no-device-selected"
+"aborted"
 /**
- * Device not found, perhaps because it doesn't have new enough firmware (for V1).
+ * **USB, BLE.** The user dismissed the device-picker dialog without
+ * selecting a device. Typically no error message is needed — the user
+ * chose not to proceed.
  */
- | "update-req"
+ | "no-device-selected"
 /**
- * Unable to claim the interface, usually because it's in use in another tab/window.
+ * **USB, BLE.** The connection type is not supported on this platform
+ * or browser. Corresponds to {@link ConnectionAvailabilityStatus}
+ * `"unsupported"`.
  */
- | "clear-connect"
+ | "unsupported"
 /**
- * The device was found to be disconnected.
+ * **BLE.** Bluetooth is turned off at the OS level. Prompt the user
+ * to enable it in system settings. Corresponds to
+ * {@link ConnectionAvailabilityStatus} `"disabled"`.
  */
- | "device-disconnected"
+ | "disabled"
 /**
- * A communication timeout occurred.
+ * **BLE.** The app does not have the required Bluetooth permissions
+ * (iOS/Android). Prompt the user to grant permission in system
+ * settings. Corresponds to {@link ConnectionAvailabilityStatus}
+ * `"permission-denied"`.
  */
- | "timeout-error"
+ | "permission-denied"
 /**
- * This is the fallback error case suggesting that the user reconnects their device.
+ * **BLE.** Location services are disabled. Required on Android
+ * versions before 12 for Bluetooth scanning. Prompt the user to
+ * enable location in system settings. Corresponds to
+ * {@link ConnectionAvailabilityStatus} `"location-disabled"`.
  */
- | "reconnect-microbit"
+ | "location-disabled"
 /**
- * Error occured during serial or bluetooth communication.
+ * **USB, BLE.** A method was called that requires an active
+ * connection, but no connection is currently open. Call
+ * {@link DeviceConnection.connect} first.
  */
- | "background-comms-error"
+ | "not-connected"
 /**
- * Bluetooth service is missing on device.
+ * **USB.** The USB interface could not be claimed, usually because
+ * another browser tab or application already has an open connection
+ * to the device.
  */
- | "service-missing"
+ | "device-in-use"
 /**
- * Failed to establish Bluetooth connection.
+ * **USB, BLE.** The device disconnected during an operation.
+ * The physical USB or Bluetooth connection was lost.
  */
- | "bluetooth-connection-failed"
+ | "device-disconnected"
 /**
- * Bluetooth is disabled on the device.
+ * **USB, BLE.** A communication timeout — the device did not respond
+ * within the expected time. This may indicate the device is busy,
+ * hung, or that the connection is degraded.
  */
- | "bluetooth-disabled"
+ | "timeout"
 /**
- * Missing required Bluetooth permissions.
+ * **USB, BLE.** A communication failure that does not match any more
+ * specific code. Typical handling: prompt the user to physically
+ * disconnect and reconnect the device, then retry.
  */
- | "bluetooth-missing-permissions"
+ | "connection-error"
 /**
- * Partial flash operation failed.
+ * **USB.** The USB device was found but lacks the expected CMSIS-DAP
+ * interface. On micro:bit V1 this indicates the DAPLink firmware is
+ * too old and needs updating.
  */
- | "flash-partial-failed"
+ | "firmware-update-required"
 /**
- * Full flash operation failed.
+ * **BLE.** The micro:bit's Bluetooth pairing/bonding information has
+ * been lost (e.g. after a firmware reflash). The user needs to
+ * re-pair the device. Currently only detected on iOS.
  */
- | "flash-full-failed"
+ | "pairing-information-lost";
 /**
- * Flash operation was cancelled.
+ * Stages reported by the progress callback during connection and flashing.
  */
- | "flash-cancelled";
-export declare enum ProgressStage {
-    Initializing = "Initializing",
-    FindingDevice = "FindingDevice",
-    Connecting = "Connecting",
-    PartialFlashing = "PartialFlashing",
-    FullFlashing = "FullFlashing"
-}
+export declare const ProgressStage: {
+    /** Checking permissions and availability before connecting. */
+    readonly Initializing: "Initializing";
+    /** Finding device. */
+    readonly FindingDevice: "FindingDevice";
+    /** Checking that a bond is established. Only applicable on Native platforms. */
+    readonly CheckingBond: "CheckingBond";
+    /** Resetting device in preparation for flashing. Only applicable on Native platforms. */
+    readonly ResettingDevice: "ResettingDevice";
+    /** Connecting for flashing. */
+    readonly Connecting: "Connecting";
+    /** Partial flashing. */
+    readonly PartialFlashing: "PartialFlashing";
+    /** Full flashing. */
+    readonly FullFlashing: "FullFlashing";
+};
+export type ProgressStage = (typeof ProgressStage)[keyof typeof ProgressStage];
 /**
  * Progress callback for tracking operation stages (connection and flashing).
  *
  * @param stage - The current stage of the operation
  * @param progress - Optional progress value (0-1) for PartialFlashing and FullFlashing stages.
- *                   Initializing, FindingDevice, and Connecting stages are called once
+ *                   Initializing, FindingDevice, CheckingBond (only for native platforms),
+ *                   ResettingDevice (only for native platforms), and Connecting stages are called once
  *                   without progress values to indicate stage entry.
  *
  * @example
@@ -102,54 +148,81 @@ export type ProgressCallback = (stage: ProgressStage, progress?: number) => void
  */
 export declare class DeviceError extends Error {
     code: DeviceErrorCode;
-    constructor({ code, message }: {
+    constructor({ code, message, cause, }: {
         code: DeviceErrorCode;
         message?: string;
+        cause?: unknown;
     });
 }
 /**
- * Tracks connection status,
+ * Asserts that a connection is active, throwing a {@link DeviceError}
+ * with code `"not-connected"` if it is not.
  */
-export declare enum ConnectionStatus {
-    /**
-     * Determining whether the connection type is supported requires
-     * initialize() to complete.
-     */
-    SUPPORT_NOT_KNOWN = "SUPPORT_NOT_KNOWN",
-    /**
-     * Not supported.
-     */
-    NOT_SUPPORTED = "NOT_SUPPORTED",
+export declare function assertConnected<T>(connection: T | undefined): asserts connection is T;
+/**
+ * Tracks connection status.
+ */
+export declare const ConnectionStatus: {
     /**
-     * Supported but no device available.
+     * No device available.
      *
-     * This will be the case even when a device is physically connected
-     * but has not been connected via the browser security UI.
-     */
-    NO_AUTHORIZED_DEVICE = "NO_AUTHORIZED_DEVICE",
-    /**
-     * Authorized device available but we haven't connected to it.
+     * This is the initial status and will be the case even when a device is
+     * physically connected but has not been connected via the browser security UI.
+     *
+     * Use checkAvailability() to determine whether the connection type is
+     * supported before attempting to connect.
      */
-    DISCONNECTED = "DISCONNECTED",
+    readonly NoAuthorizedDevice: "NoAuthorizedDevice";
+    /** Authorized device available but we haven't connected to it. */
+    readonly Disconnected: "Disconnected";
+    /** Connected. */
+    readonly Connected: "Connected";
+    /** Connecting. */
+    readonly Connecting: "Connecting";
     /**
-     * Connected.
+     * Paused due to tab visibility. The connection was temporarily suspended
+     * because the browser tab became hidden. Reconnection will be attempted
+     * automatically when the tab becomes visible again.
      */
-    CONNECTED = "CONNECTED",
+    readonly Paused: "Paused";
+};
+export type ConnectionStatus = (typeof ConnectionStatus)[keyof typeof ConnectionStatus];
+/**
+ * Controls bonding behaviour and post-bond device mode on native platforms.
+ *
+ * - `"pairing"` — Bond if needed, then reset the device into pairing mode.
+ *   Use when you intend to flash immediately after connecting.
+ * - `"application"` — Bond if needed, then reset the device into application
+ *   mode. Use when you want to interact with BLE services (sensors, UART, …)
+ *   on firmware that has BLE enabled in application mode.
+ * - `"none"` — Skip bonding entirely and just connect. Use for open-link
+ *   firmware where no bonding is required.
+ *
+ * Ignored on web platforms where the browser manages pairing transparently.
+ */
+export type BondMode = "pairing" | "application" | "none";
+export interface ConnectOptions {
     /**
-     * Connecting.
+     * Optional progress callback for tracking connection stages.
      */
-    CONNECTING = "CONNECTING",
+    progress?: ProgressCallback;
     /**
-     * Reconnecting. When there is unexpected disruption in the connection,
-     * a reconnection is attempted.
+     * Optional AbortSignal to abort the connection attempt.
+     * When aborted, the connect promise will reject with a DeviceError
+     * with code "aborted".
+     *
+     * Note: Currently only aborts during the FindingDevice stage on native
+     * platforms. Web platform device selection (browser picker) cannot be
+     * aborted programmatically.
      */
-    RECONNECTING = "RECONNECTING"
-}
-export interface ConnectOptions {
+    signal?: AbortSignal;
     /**
-     * Optional progress callback for tracking connection stages.
+     * Controls bonding and post-bond device mode on native platforms.
+     * Ignored on web. Default: `"pairing"`.
+     *
+     * @see {@link BondMode}
      */
-    progress?: ProgressCallback;
+    bondMode?: BondMode;
 }
 export interface FlashOptions {
     /**
@@ -169,38 +242,62 @@ export interface FlashOptions {
      * Smallest possible progress increment to limit callback rate.
      */
     minimumProgressIncrement?: number;
+    /**
+     * Optional AbortSignal to abort the flash operation.
+     * When aborted, the flash promise will reject with a DeviceError
+     * with code "aborted".
+     *
+     * Note: Currently only aborts during the FindingDevice stage on native
+     * platforms. Once a device is found and flashing begins, the operation
+     * cannot be aborted.
+     */
+    signal?: AbortSignal;
 }
 export declare class FlashDataError extends Error {
 }
 export type FlashDataSource = (boardVersion: BoardVersion) => Promise<string | Uint8Array>;
 export type BoardVersion = "V1" | "V2";
-export declare class ConnectionStatusEvent extends Event {
-    readonly status: ConnectionStatus;
-    constructor(status: ConnectionStatus);
-}
-export declare class BeforeRequestDevice extends Event {
-    constructor();
-}
-export declare class AfterRequestDevice extends Event {
-    constructor();
+export interface ConnectionStatusChange {
+    status: ConnectionStatus;
+    previousStatus: ConnectionStatus;
 }
-export declare class BackgroundErrorEvent extends Event {
-    readonly errorMessage: string;
-    readonly error?: unknown | undefined;
-    constructor(errorMessage: string, error?: unknown | undefined);
+export interface BackgroundErrorData {
+    error: DeviceError;
+    event?: string;
 }
-export declare class DeviceConnectionEventMap {
-    "status": ConnectionStatusEvent;
-    "backgrounderror": BackgroundErrorEvent;
-    "beforerequestdevice": Event;
-    "afterrequestdevice": Event;
+export interface DeviceConnectionEventMap {
+    status: ConnectionStatusChange;
+    backgrounderror: BackgroundErrorData;
+    beforerequestdevice: void;
+    afterrequestdevice: void;
+    flash: void;
 }
-export interface DeviceConnection<M extends ValueIsEvent<M>> extends TypedEventTarget<DeviceConnectionEventMap & M> {
+export interface DeviceConnection {
+    addEventListener(type: "status", listener: (data: ConnectionStatusChange) => void): void;
+    addEventListener(type: "backgrounderror", listener: (data: BackgroundErrorData) => void): void;
+    addEventListener(type: "beforerequestdevice", listener: () => void): void;
+    addEventListener(type: "afterrequestdevice", listener: () => void): void;
+    addEventListener(type: "flash", listener: () => void): void;
+    removeEventListener(type: "status", listener: (data: ConnectionStatusChange) => void): void;
+    removeEventListener(type: "backgrounderror", listener: (data: BackgroundErrorData) => void): void;
+    removeEventListener(type: "beforerequestdevice", listener: () => void): void;
+    removeEventListener(type: "afterrequestdevice", listener: () => void): void;
+    removeEventListener(type: "flash", listener: () => void): void;
+    readonly type: string;
     status: ConnectionStatus;
     /**
      * Initializes the device.
      */
     initialize(): Promise<void>;
+    /**
+     * Checks if this connection type is currently available.
+     *
+     * Use this for pre-flight UX decisions (e.g., showing "enable Bluetooth" dialog).
+     * Note: Even if this returns "available", connect() can still fail.
+     *
+     * @returns A promise resolving to the current availability status.
+     */
+    checkAvailability(): Promise<ConnectionAvailabilityStatus>;
     /**
      * Removes all listeners.
      */
@@ -208,29 +305,49 @@ export interface DeviceConnection<M extends ValueIsEvent<M>> extends TypedEventT
     /**
      * Connects to a currently paired device or requests pairing.
      *
-     * @param options Optional connection options including progress callback.
+     * @param options Optional connection options including progress callback and abort signal.
      * @throws {DeviceError} On connection failure. The error.code property indicates the failure type.
      */
     connect(options?: ConnectOptions): Promise<void>;
     /**
      * Get the board version.
      *
-     * @returns the board version or undefined if there is no connection.
+     * Cached after the first successful connection until {@link clearDevice}
+     * is called, so remains available after disconnection.
+     *
+     * @returns the board version.
+     * @throws {DeviceError} with code `not-connected` if no device has been connected.
      */
-    getBoardVersion(): BoardVersion | undefined;
+    getBoardVersion(): BoardVersion;
     /**
      * Disconnect from the device.
      */
     disconnect(): Promise<void>;
     /**
-     * Write serial data to the device.
+     * Flash the micro:bit.
+     *
+     * Not all connection types support flashing. For example, radio bridge
+     * connections do not support flashing, and Bluetooth connections only
+     * support flashing on native platforms (not Web).
+     *
+     * Post-flash connection state differs by transport:
+     *
+     * - **USB**: The connection remains in {@link ConnectionStatus.Connected} state.
+     *   USB connects to the micro:bit's interface chip (running DAPLink firmware),
+     *   which is not affected by flashing the application processor, so the
+     *   connection persists and serial communication is automatically reinitialised.
      *
-     * Does nothing if there is no connection.
+     * - **Bluetooth**: The connection is always left in {@link ConnectionStatus.Disconnected}
+     *   state. Bluetooth connects to the application processor directly, which
+     *   reboots after flashing, so the connection is necessarily lost. Callers
+     *   must call {@link connect} again after flashing.
      *
-     * @param data The data to write.
-     * @returns A promise that resolves when the write is complete.
+     * @param dataSource The data to use.
+     * @param options Flash options and progress callback.
+     * @throws {DeviceError} On flash failure. The error.code property indicates the failure type.
+     * @throws {FlashDataError} If data preparation fails.
      */
-    serialWrite(data: string): Promise<void>;
+    flash?(dataSource: FlashDataSource, options: FlashOptions): Promise<void>;
     /**
      * Clear device to enable chooseDevice.
      */

package/build/esm/device.js

@@ -1,11 +1,27 @@
-export var ProgressStage;
-(function (ProgressStage) {
-    ProgressStage["Initializing"] = "Initializing";
-    ProgressStage["FindingDevice"] = "FindingDevice";
-    ProgressStage["Connecting"] = "Connecting";
-    ProgressStage["PartialFlashing"] = "PartialFlashing";
-    ProgressStage["FullFlashing"] = "FullFlashing";
-})(ProgressStage || (ProgressStage = {}));
+/**
+ * (c) 2021, Micro:bit Educational Foundation and contributors
+ *
+ * SPDX-License-Identifier: MIT
+ */
+/**
+ * Stages reported by the progress callback during connection and flashing.
+ */
+export const ProgressStage = {
+    /** Checking permissions and availability before connecting. */
+    Initializing: "Initializing",
+    /** Finding device. */
+    FindingDevice: "FindingDevice",
+    /** Checking that a bond is established. Only applicable on Native platforms. */
+    CheckingBond: "CheckingBond",
+    /** Resetting device in preparation for flashing. Only applicable on Native platforms. */
+    ResettingDevice: "ResettingDevice",
+    /** Connecting for flashing. */
+    Connecting: "Connecting",
+    /** Partial flashing. */
+    PartialFlashing: "PartialFlashing",
+    /** Full flashing. */
+    FullFlashing: "FullFlashing",
+};
 /**
  * Error type used for all interactions with this module.
  *
@@ -16,8 +32,8 @@ export var ProgressStage;
  * English.
  */
 export class DeviceError extends Error {
-    constructor({ code, message }) {
-        super(message);
+    constructor({ code, message, cause, }) {
+        super(message, { cause });
         Object.defineProperty(this, "code", {
             enumerable: true,
             configurable: true,
@@ -28,110 +44,41 @@ export class DeviceError extends Error {
     }
 }
 /**
- * Tracks connection status,
+ * Asserts that a connection is active, throwing a {@link DeviceError}
+ * with code `"not-connected"` if it is not.
  */
-export var ConnectionStatus;
-(function (ConnectionStatus) {
-    /**
-     * Determining whether the connection type is supported requires
-     * initialize() to complete.
-     */
-    ConnectionStatus["SUPPORT_NOT_KNOWN"] = "SUPPORT_NOT_KNOWN";
-    /**
-     * Not supported.
-     */
-    ConnectionStatus["NOT_SUPPORTED"] = "NOT_SUPPORTED";
+export function assertConnected(connection) {
+    if (!connection) {
+        throw new DeviceError({ code: "not-connected", message: "Not connected" });
+    }
+}
+/**
+ * Tracks connection status.
+ */
+export const ConnectionStatus = {
     /**
-     * Supported but no device available.
+     * No device available.
      *
-     * This will be the case even when a device is physically connected
-     * but has not been connected via the browser security UI.
-     */
-    ConnectionStatus["NO_AUTHORIZED_DEVICE"] = "NO_AUTHORIZED_DEVICE";
-    /**
-     * Authorized device available but we haven't connected to it.
-     */
-    ConnectionStatus["DISCONNECTED"] = "DISCONNECTED";
-    /**
-     * Connected.
-     */
-    ConnectionStatus["CONNECTED"] = "CONNECTED";
-    /**
-     * Connecting.
+     * This is the initial status and will be the case even when a device is
+     * physically connected but has not been connected via the browser security UI.
+     *
+     * Use checkAvailability() to determine whether the connection type is
+     * supported before attempting to connect.
      */
-    ConnectionStatus["CONNECTING"] = "CONNECTING";
+    NoAuthorizedDevice: "NoAuthorizedDevice",
+    /** Authorized device available but we haven't connected to it. */
+    Disconnected: "Disconnected",
+    /** Connected. */
+    Connected: "Connected",
+    /** Connecting. */
+    Connecting: "Connecting",
     /**
-     * Reconnecting. When there is unexpected disruption in the connection,
-     * a reconnection is attempted.
+     * Paused due to tab visibility. The connection was temporarily suspended
+     * because the browser tab became hidden. Reconnection will be attempted
+     * automatically when the tab becomes visible again.
      */
-    ConnectionStatus["RECONNECTING"] = "RECONNECTING";
-})(ConnectionStatus || (ConnectionStatus = {}));
+    Paused: "Paused",
+};
 export class FlashDataError extends Error {
 }
-export class ConnectionStatusEvent extends Event {
-    constructor(status) {
-        super("status");
-        Object.defineProperty(this, "status", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: status
-        });
-    }
-}
-export class BeforeRequestDevice extends Event {
-    constructor() {
-        super("beforerequestdevice");
-    }
-}
-export class AfterRequestDevice extends Event {
-    constructor() {
-        super("afterrequestdevice");
-    }
-}
-export class BackgroundErrorEvent extends Event {
-    constructor(errorMessage, error) {
-        super("backgrounderror");
-        Object.defineProperty(this, "errorMessage", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: errorMessage
-        });
-        Object.defineProperty(this, "error", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: error
-        });
-    }
-}
-export class DeviceConnectionEventMap {
-    constructor() {
-        Object.defineProperty(this, "status", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "backgrounderror", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "beforerequestdevice", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "afterrequestdevice", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-    }
-}
 //# sourceMappingURL=device.js.map

package/build/esm/device.js.map

@@ -1 +1 @@
-{"version":3,"file":"device.js","sourceRoot":"","sources":["../../lib/device.ts"],"names":[],"mappings":"AAsEA,MAAM,CAAN,IAAY,aAMX;AAND,WAAY,aAAa;IACvB,8CAA6B,CAAA;IAC7B,gDAA+B,CAAA;IAC/B,0CAAyB,CAAA;IACzB,oDAAmC,CAAA;IACnC,8CAA6B,CAAA;AAC/B,CAAC,EANW,aAAa,KAAb,aAAa,QAMxB;AAwBD;;;;;;;;GAQG;AACH,MAAM,OAAO,WAAY,SAAQ,KAAK;IAEpC,YAAY,EAAE,IAAI,EAAE,OAAO,EAA+C;QACxE,KAAK,CAAC,OAAO,CAAC,CAAC;QAFjB;;;;;WAAsB;QAGpB,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;IACnB,CAAC;CACF;AAED;;GAEG;AACH,MAAM,CAAN,IAAY,gBAkCX;AAlCD,WAAY,gBAAgB;IAC1B;;;OAGG;IACH,2DAAuC,CAAA;IACvC;;OAEG;IACH,mDAA+B,CAAA;IAC/B;;;;;OAKG;IACH,iEAA6C,CAAA;IAC7C;;OAEG;IACH,iDAA6B,CAAA;IAC7B;;OAEG;IACH,2CAAuB,CAAA;IACvB;;OAEG;IACH,6CAAyB,CAAA;IACzB;;;OAGG;IACH,iDAA6B,CAAA;AAC/B,CAAC,EAlCW,gBAAgB,KAAhB,gBAAgB,QAkC3B;AA6BD,MAAM,OAAO,cAAe,SAAQ,KAAK;CAAG;AAQ5C,MAAM,OAAO,qBAAsB,SAAQ,KAAK;IAC9C,YAA4B,MAAwB;QAClD,KAAK,CAAC,QAAQ,CAAC,CAAC;QADN;;;;mBAAgB,MAAM;WAAkB;IAEpD,CAAC;CACF;AAED,MAAM,OAAO,mBAAoB,SAAQ,KAAK;IAC5C;QACE,KAAK,CAAC,qBAAqB,CAAC,CAAC;IAC/B,CAAC;CACF;AAED,MAAM,OAAO,kBAAmB,SAAQ,KAAK;IAC3C;QACE,KAAK,CAAC,oBAAoB,CAAC,CAAC;IAC9B,CAAC;CACF;AAED,MAAM,OAAO,oBAAqB,SAAQ,KAAK;IAC7C,YACkB,YAAoB,EACpB,KAAe;QAE/B,KAAK,CAAC,iBAAiB,CAAC,CAAC;QAHzB;;;;mBAAgB,YAAY;WAAQ;QACpC;;;;mBAAgB,KAAK;WAAU;IAGjC,CAAC;CACF;AAED,MAAM,OAAO,wBAAwB;IAArC;QACE,4BAAA,QAAQ;;;;;WAAwB;QAChC,4BAAA,iBAAiB;;;;;WAAuB;QACxC,4BAAA,qBAAqB;;;;;WAAQ;QAC7B,4BAAA,oBAAoB;;;;;WAAQ;IAC9B,CAAC;CAAA"}
+{"version":3,"file":"device.js","sourceRoot":"","sources":["../../src/device.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAsHH;;GAEG;AACH,MAAM,CAAC,MAAM,aAAa,GAAG;IAC3B,+DAA+D;IAC/D,YAAY,EAAE,cAAc;IAC5B,sBAAsB;IACtB,aAAa,EAAE,eAAe;IAC9B,gFAAgF;IAChF,YAAY,EAAE,cAAc;IAC5B,yFAAyF;IACzF,eAAe,EAAE,iBAAiB;IAClC,+BAA+B;IAC/B,UAAU,EAAE,YAAY;IACxB,wBAAwB;IACxB,eAAe,EAAE,iBAAiB;IAClC,qBAAqB;IACrB,YAAY,EAAE,cAAc;CACpB,CAAC;AA2BX;;;;;;;;GAQG;AACH,MAAM,OAAO,WAAY,SAAQ,KAAK;IAEpC,YAAY,EACV,IAAI,EACJ,OAAO,EACP,KAAK,GAKN;QACC,KAAK,CAAC,OAAO,EAAE,EAAE,KAAK,EAAE,CAAC,CAAC;QAV5B;;;;;WAAsB;QAWpB,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;IACnB,CAAC;CACF;AAED;;;GAGG;AACH,MAAM,UAAU,eAAe,CAC7B,UAAyB;IAEzB,IAAI,CAAC,UAAU,EAAE,CAAC;QAChB,MAAM,IAAI,WAAW,CAAC,EAAE,IAAI,EAAE,eAAe,EAAE,OAAO,EAAE,eAAe,EAAE,CAAC,CAAC;IAC7E,CAAC;AACH,CAAC;AAED;;GAEG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG;IAC9B;;;;;;;;OAQG;IACH,kBAAkB,EAAE,oBAAoB;IACxC,kEAAkE;IAClE,YAAY,EAAE,cAAc;IAC5B,iBAAiB;IACjB,SAAS,EAAE,WAAW;IACtB,kBAAkB;IAClB,UAAU,EAAE,YAAY;IACxB;;;;OAIG;IACH,MAAM,EAAE,QAAQ;CACR,CAAC;AA0EX,MAAM,OAAO,cAAe,SAAQ,KAAK;CAAG"}