yoto-nodejs-client 0.0.1 → 0.0.3

package/lib/mqtt/topics.js

@@ -11,7 +11,7 @@
 
 /**
  * MQTT topic type for subscriptions
- * @typedef {'events' | 'status' | 'response'} YotoMqttTopicType
+ * @typedef {'events' | 'status' | 'status-legacy' | 'response'} YotoMqttTopicType
  */
 
 /**
@@ -45,28 +45,47 @@ export const MQTT_KEEPALIVE = 300
 export const MQTT_ALPN_PROTOCOLS = ['x-amzn-mqtt-ca']
 
 /**
- * Get the events topics for a device (both old and new formats)
- * Devices publish to both paths, so both are returned
+ * Get the events topics for a device
+ *
+ * NOTE: Old undocumented format device/{id}/events exists but returns different low-level
+ * hardware data. Do not use. Only the documented /data/ path is supported.
+ *
  * @param {string} deviceId - Device ID
- * @returns {string[]} Events topics [old format, new format]
+ * @returns {string[]} Events topics
  */
 export function getEventsTopic (deviceId) {
   return [
-    `device/${deviceId}/events`,           // Old path (still published)
-    `device/${deviceId}/data/events`       // New path (also published)
+    // `device/${deviceId}/events`,           // OLD UNDOCUMENTED FORMAT - DO NOT USE (low-level hardware data, different schema)
+    `device/${deviceId}/data/events`       // Documented format - use this
   ]
 }
 
 /**
- * Get the status topics for a device (both old and new formats)
- * Devices publish to both paths, so both are returned
+ * Get the status topics for a device
+ *
+ * Subscribes to BOTH documented and legacy status topics:
+ * - device/{id}/data/status: Documented format - responds to requestStatus(), auto-publishes every 5 min
+ * - device/{id}/status: Legacy format - does NOT respond to requests, emits on lifecycle events + every 5 min
+ *
+ * The legacy topic is the ONLY source for:
+ * - shutDown field: 'nA' = device running, any other value = device shutting down/shut down
+ * - Startup detection: shutDown='nA' + low upTime values + utcTime: 0 after power on
+ * - Full hardware diagnostics: battery voltage, memory stats, temperatures
+ *
+ * Key behavior differences:
+ * - Documented topic: Responds immediately to requestStatus() command
+ * - Legacy topic: Emits real-time on shutdown/startup events, plus periodic updates every 5 minutes
+ * - Legacy topic does NOT respond to requestStatus() - it's passive/event-driven only
+ *
+ * Both topics are necessary - the documented /data/ path does not include lifecycle events.
+ *
  * @param {string} deviceId - Device ID
- * @returns {string[]} Status topics [old format, new format]
+ * @returns {string[]} Status topics (both documented and legacy)
  */
 export function getStatusTopic (deviceId) {
   return [
-    `device/${deviceId}/status`,           // Old path (still published)
-    `device/${deviceId}/data/status`       // New path (also published)
+    `device/${deviceId}/data/status`,      // Documented format - regular status updates
+    `device/${deviceId}/status`            // Legacy format - REQUIRED for lifecycle events (shutDown, startup)
   ]
 }
 
@@ -82,20 +101,24 @@ export function getResponseTopic (deviceId) {
 /**
  * Get all subscription topics for a device
  *
- * Subscribes to both old and new topic formats because Yoto devices publish to both:
- * - Old format: device/{id}/events, device/{id}/status
- * - New format: device/{id}/data/events, device/{id}/data/status
+ * Subscribes to documented formats PLUS legacy status topic:
+ * - device/{id}/data/events - Event messages (documented)
+ * - device/{id}/data/status - Status messages (documented)
+ * - device/{id}/status - Legacy status (REQUIRED for shutdown/startup lifecycle events)
+ * - device/{id}/response - Command responses (documented)
  *
- * This ensures all messages are received regardless of which path the device uses.
+ * The legacy status topic is necessary because the documented /data/ topics do not
+ * include device lifecycle events (shutdown, startup) which are critical for proper
+ * device state management.
  *
  * @param {string} deviceId - Device ID
- * @returns {string[]} Array of topics to subscribe to (includes both old and new formats)
+ * @returns {string[]} Array of topics to subscribe to
  */
 export function getSubscriptionTopics (deviceId) {
   return [
-    ...getEventsTopic(deviceId),           // Both events topics
-    ...getStatusTopic(deviceId),           // Both status topics
-    getResponseTopic(deviceId)             // Response topic (no old/new variants)
+    ...getEventsTopic(deviceId),           // Events topic (documented format)
+    ...getStatusTopic(deviceId),           // Status topics (documented + legacy for lifecycle)
+    getResponseTopic(deviceId)             // Response topic
   ]
 }
 
@@ -113,6 +136,11 @@ export function getCommandTopic (deviceId, resource, action) {
 
 /**
  * Parse a topic string to extract device ID and message type
+ *
+ * Distinguishes between documented and legacy status topics:
+ * - device/{id}/data/status -> messageType: 'status' (documented)
+ * - device/{id}/status -> messageType: 'status-legacy' (for lifecycle events)
+ *
  * @param {string} topic - Full MQTT topic string
  * @returns {{ deviceId: string, messageType: YotoMqttTopicType | 'unknown' }} Parsed topic info
  */
@@ -125,10 +153,16 @@ export function parseTopic (topic) {
 
   const deviceId = parts[1] || ''
 
-  // Handle both old format (device/{id}/events) and new format (device/{id}/data/events)
+  // Handle both documented format (device/{id}/data/status) and legacy format (device/{id}/status)
   let messageType = parts[2]
+
   if (messageType === 'data' && parts.length >= 4) {
+    // Documented format: device/{id}/data/{type}
     messageType = parts[3] // Get the actual message type after /data/
+  } else if (messageType === 'status') {
+    // Legacy format: device/{id}/status
+    // Return 'status-legacy' to distinguish from documented status
+    return { deviceId, messageType: 'status-legacy' }
   }
 
   // Validate message type

package/lib/pkg.d.cts

@@ -7,6 +7,7 @@ export const pkg: {
         url: string;
     };
     dependencies: {
+        "@unblessed/node": string;
         "jwt-decode": string;
         mqtt: string;
         undici: string;
@@ -17,6 +18,7 @@ export const pkg: {
         argsclopts: string;
         "auto-changelog": string;
         c8: string;
+        eslint: string;
         "gh-release": string;
         neostandard: string;
         "npm-run-all2": string;
@@ -37,6 +39,13 @@ export const pkg: {
     bin: {
         "yoto-auth": string;
         "yoto-token-info": string;
+        "yoto-refresh-token": string;
+        "yoto-devices": string;
+        "yoto-device-model": string;
+        "yoto-device-tui": string;
+        "yoto-content": string;
+        "yoto-groups": string;
+        "yoto-icons": string;
     };
     repository: {
         type: string;

package/lib/token.d.ts

@@ -1,24 +1,127 @@
+/**
+ * @typedef {Object} RefreshableTokenOpts
+ * @property {string} clientId - OAuth client ID
+ * @property {string} refreshToken - OAuth refresh token
+ * @property {string} accessToken - Initial OAuth access token (JWT)
+ * @property {number} [bufferSeconds=30] - Seconds before expiration to consider token expired
+ */
+/**
+ * @typedef {Object} RefreshSuccessEvent
+ * @property {string} clientId - The OAuth client ID
+ * @property {string} updatedAccessToken - The new access token
+ * @property {string} updatedRefreshToken - The refresh token (may be updated)
+ * @property {number} updatedExpiresAt - Unix timestamp in seconds when token expires
+ * @property {string} prevAccessToken - The accessToken used in to initiate the refresh flow to be discarded
+ * @property {string} prevRefreshToken - The refreshToken used in to initiate the refresh flow to be discarded
+ * @property {number} prevExpiresAt - The expiresAt for the previous token pair
+ */
+/**
+ * Event map for RefreshableToken
+ * @typedef {{
+ *   'refresh:start': [],
+ *   'refresh:success': [RefreshSuccessEvent],
+ *   'refresh:error': [Error],
+ *   'invalid': [Error]
+ * }} RefreshableTokenEventMap
+ */
+/**
+ * A refreshable OAuth token that automatically refreshes when expired.
+ * Handles in-flight refresh deduplication to prevent multiple concurrent refresh requests.
+ *
+ * Events:
+ * - 'refresh:start' - Emitted when token refresh begins
+ * - 'refresh:success' - Emitted when token refresh succeeds, passes { clientId, accessToken, refreshToken, expiresAt }
+ * - 'refresh:error' - Emitted when token refresh fails (transient errors), passes error
+ * - 'invalid' - Emitted when refresh token is permanently invalid, passes error
+ *
+ * @extends {EventEmitter<RefreshableTokenEventMap>}
+ */
 export class RefreshableToken extends EventEmitter<RefreshableTokenEventMap> {
+    /**
+     * @param {RefreshableTokenOpts} opts
+     */
     constructor({ clientId, refreshToken, accessToken, bufferSeconds }: RefreshableTokenOpts);
+    /**
+     * Get a valid access token, refreshing if necessary.
+     * @returns {Promise<string>} Valid access token
+     * @throws {Error} If token is invalid or refresh fails
+     */
     getAccessToken(): Promise<string>;
+    /**
+     * Check if the token is currently valid (not expired and not marked invalid).
+     * @returns {boolean} True if token is valid
+     */
     isValid(): boolean;
+    /**
+     * Get the expiration timestamp of the current access token.
+     * @returns {number} Unix timestamp (seconds since epoch)
+     */
     getExpiresAt(): number;
+    /**
+     * Get the time remaining until token expiration.
+     * @returns {number} Seconds until expiration (may be negative if expired)
+     */
     getTimeRemaining(): number;
+    /**
+     * Manually trigger a token refresh, regardless of expiration status.
+     * Useful for proactive refresh or testing.
+     * @returns {Promise<RefreshSuccessEvent>} Token information including clientId, accessToken, refreshToken, and expiresAt
+     * @throws {Error} If token is invalid or refresh fails
+     */
     refresh(): Promise<RefreshSuccessEvent>;
     #private;
 }
 export type RefreshableTokenOpts = {
+    /**
+     * - OAuth client ID
+     */
     clientId: string;
+    /**
+     * - OAuth refresh token
+     */
     refreshToken: string;
+    /**
+     * - Initial OAuth access token (JWT)
+     */
     accessToken: string;
+    /**
+     * - Seconds before expiration to consider token expired
+     */
     bufferSeconds?: number;
 };
 export type RefreshSuccessEvent = {
+    /**
+     * - The OAuth client ID
+     */
     clientId: string;
-    accessToken: string;
-    refreshToken: string;
-    expiresAt: number;
+    /**
+     * - The new access token
+     */
+    updatedAccessToken: string;
+    /**
+     * - The refresh token (may be updated)
+     */
+    updatedRefreshToken: string;
+    /**
+     * - Unix timestamp in seconds when token expires
+     */
+    updatedExpiresAt: number;
+    /**
+     * - The accessToken used in to initiate the refresh flow to be discarded
+     */
+    prevAccessToken: string;
+    /**
+     * - The refreshToken used in to initiate the refresh flow to be discarded
+     */
+    prevRefreshToken: string;
+    /**
+     * - The expiresAt for the previous token pair
+     */
+    prevExpiresAt: number;
 };
+/**
+ * Event map for RefreshableToken
+ */
 export type RefreshableTokenEventMap = {
     "refresh:start": [];
     "refresh:success": [RefreshSuccessEvent];

package/lib/token.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"token.d.ts","sourceRoot":"","sources":["token.js"],"names":[],"mappings":"AA0CA;IAmBE,oEAFW,oBAAoB,EAoB9B;IAOD,kBAHa,OAAO,CAAC,MAAM,CAAC,CAiB3B;IA4FD,WAFa,OAAO,CASnB;IAMD,gBAFa,MAAM,CAIlB;IAMD,oBAFa,MAAM,CAKlB;IAQD,WAHa,OAAO,CAAC,mBAAmB,CAAC,CAiBxC;;CACF;;cAzOa,MAAM;kBACN,MAAM;iBACN,MAAM;oBACN,MAAM;;;cAKN,MAAM;iBACN,MAAM;kBACN,MAAM;eACN,MAAM;;uCAKP;IACZ,eAAmB,EAAE,EAAE,CAAC;IACxB,iBAAqB,EAAE,CAAC,mBAAmB,CAAC,CAAC;IAC7C,eAAmB,EAAE,CAAC,KAAK,CAAC,CAAC;IAC7B,SAAa,EAAE,CAAC,KAAK,CAAC,CAAA;CACnB;6BA3ByB,aAAa"}
+{"version":3,"file":"token.d.ts","sourceRoot":"","sources":["token.js"],"names":[],"mappings":"AAIA;;;;;;GAMG;AAEH;;;;;;;;;GASG;AAEH;;;;;;;;GAQG;AAEH;;;;;;;;;;;GAWG;AACH;IAgBE;;OAEG;IACH,oEAFW,oBAAoB,EAoB9B;IAED;;;;OAIG;IACH,kBAHa,OAAO,CAAC,MAAM,CAAC,CAkB3B;IAkGD;;;OAGG;IACH,WAFa,OAAO,CASnB;IAED;;;OAGG;IACH,gBAFa,MAAM,CAIlB;IAED;;;OAGG;IACH,oBAFa,MAAM,CAKlB;IAED;;;;;OAKG;IACH,WAHa,OAAO,CAAC,mBAAmB,CAAC,CAUxC;;CACF;;;;;cAhPa,MAAM;;;;kBACN,MAAM;;;;iBACN,MAAM;;;;oBACN,MAAM;;;;;;cAKN,MAAM;;;;wBACN,MAAM;;;;yBACN,MAAM;;;;sBACN,MAAM;;;;qBACN,MAAM;;;;sBACN,MAAM;;;;mBACN,MAAM;;;;;uCAKP;IACZ,eAAmB,EAAE,EAAE,CAAC;IACxB,iBAAqB,EAAE,CAAC,mBAAmB,CAAC,CAAC;IAC7C,eAAmB,EAAE,CAAC,KAAK,CAAC,CAAC;IAC7B,SAAa,EAAE,CAAC,KAAK,CAAC,CAAA;CACnB;6BA9ByB,aAAa"}

package/lib/token.js

@@ -13,9 +13,12 @@ import { exchangeToken } from './api-endpoints/auth.js'
 /**
  * @typedef {Object} RefreshSuccessEvent
  * @property {string} clientId - The OAuth client ID
- * @property {string} accessToken - The new access token
- * @property {string} refreshToken - The refresh token (may be updated)
- * @property {number} expiresAt - Unix timestamp in seconds when token expires
+ * @property {string} updatedAccessToken - The new access token
+ * @property {string} updatedRefreshToken - The refresh token (may be updated)
+ * @property {number} updatedExpiresAt - Unix timestamp in seconds when token expires
+ * @property {string} prevAccessToken - The accessToken used in to initiate the refresh flow to be discarded
+ * @property {string} prevRefreshToken - The refreshToken used in to initiate the refresh flow to be discarded
+ * @property {number} prevExpiresAt - The expiresAt for the previous token pair
  */
 
 /**
@@ -53,7 +56,7 @@ export class RefreshableToken extends EventEmitter {
   #bufferSeconds
   /** @type {boolean} */
   #invalid = false
-  /** @type {Promise<string> | null} */
+  /** @type {Promise<RefreshSuccessEvent> | null} */
   #inFlightRefresh = null
 
   /**
@@ -97,13 +100,14 @@ export class RefreshableToken extends EventEmitter {
       return this.#accessToken
     }
 
-    return await this.#refreshAccessToken()
+    const { updatedAccessToken } = await this.#refreshAccessToken()
+    return updatedAccessToken
   }
 
   /**
    * Refresh the access token using the refresh token.
    * Handles in-flight request deduplication.
-   * @returns {Promise<string>} New access token
+   * @returns {Promise<RefreshSuccessEvent>} New access token
    */
   async #refreshAccessToken () {
     // If a refresh is already in flight, await the existing one
@@ -114,8 +118,7 @@ export class RefreshableToken extends EventEmitter {
     // Create the refresh promise and set it on the class variable
     try {
       this.#inFlightRefresh = this.#performRefresh()
-      const newAccessToken = await this.#inFlightRefresh
-      return newAccessToken
+      return await this.#inFlightRefresh
     } finally {
       // Clear the in-flight refresh once done
       this.#inFlightRefresh = null
@@ -124,12 +127,17 @@ export class RefreshableToken extends EventEmitter {
 
   /**
    * Perform the actual token refresh.
-   * @returns {Promise<string>} New access token
+   * @returns {Promise<RefreshSuccessEvent>} New access token
    */
   async #performRefresh () {
     this.emit('refresh:start')
 
     try {
+      // Snapshot the current tokens
+      const prevAccessToken = this.#accessToken
+      const prevRefreshToken = this.#refreshToken
+      const prevExpiresAt = this.#expiresAt
+
       const tokens = await exchangeToken({
         grantType: 'refresh_token',
         refreshToken: this.#refreshToken,
@@ -151,14 +159,20 @@ export class RefreshableToken extends EventEmitter {
       }
       this.#expiresAt = decoded.exp
 
-      this.emit('refresh:success', {
+      /* @type {RefreshSuccessEvent} */
+      const eventPayload = {
         clientId: this.#clientId,
-        accessToken: this.#accessToken,
-        refreshToken: this.#refreshToken,
-        expiresAt: this.#expiresAt
-      })
+        updatedAccessToken: this.#accessToken,
+        updatedRefreshToken: this.#refreshToken,
+        updatedExpiresAt: this.#expiresAt,
+        prevAccessToken,
+        prevRefreshToken,
+        prevExpiresAt,
+      }
 
-      return this.#accessToken
+      this.emit('refresh:success', eventPayload)
+
+      return eventPayload
     } catch (err) {
       const error = /** @type {any} */ (err)
 
@@ -228,13 +242,6 @@ export class RefreshableToken extends EventEmitter {
       throw new Error('Token is invalid. Refresh token has expired or been revoked.')
     }
 
-    await this.#refreshAccessToken()
-
-    return {
-      clientId: this.#clientId,
-      accessToken: this.#accessToken,
-      refreshToken: this.#refreshToken,
-      expiresAt: this.#expiresAt
-    }
+    return await this.#refreshAccessToken()
   }
 }

package/lib/yoto-account.d.ts

@@ -0,0 +1,163 @@
+/**
+ * Yoto Account initialization options
+ * @typedef {Object} YotoAccountOptions
+ * @property {YotoClientConstructorOptions} clientOptions - Yoto API client Options
+ * @property {YotoDeviceModelOptions} deviceOptions - Yoto Device Model Options
+ */
+/**
+ * Error context information
+ * @typedef {Object} YotoAccountErrorContext
+ * @property {string} source - Error source ('account', 'client', or deviceId)
+ * @property {string} [deviceId] - Device ID if error is device-specific
+ * @property {string} [operation] - Operation that failed
+ */
+/**
+ * Started event metadata
+ * @typedef {Object} YotoAccountStartedMetadata
+ * @property {number} deviceCount - Number of devices managed
+ * @property {string[]} devices - Array of device IDs
+ */
+/**
+ * Event map for YotoAccount
+ * @typedef {{
+ *   'started': [YotoAccountStartedMetadata],
+ *   'stopped': [],
+ *   'deviceAdded': [string, YotoDeviceModel],
+ *   'deviceRemoved': [string],
+ *   'error': [Error, YotoAccountErrorContext]
+ * }} YotoAccountEventMap
+ */
+/**
+ * Yoto Account client that manages all devices for an account
+ *
+ * Events:
+ * - 'started' - Emitted when account starts, passes metadata with deviceCount and devices array
+ * - 'stopped' - Emitted when account stops
+ * - 'deviceAdded' - Emitted when a device is added, passes (deviceId, deviceModel)
+ * - 'deviceRemoved' - Emitted when a device is removed, passes deviceId
+ * - 'error' - Emitted when an error occurs, passes (error, context)
+ *
+ * Note: To listen to individual device events (statusUpdate, configUpdate, playbackUpdate, online, offline, etc.),
+ * access the device models directly via account.devices or account.getDevice(deviceId) and attach listeners.
+ *
+ * @extends {EventEmitter<YotoAccountEventMap>}
+ */
+export class YotoAccount extends EventEmitter<YotoAccountEventMap> {
+    /**
+      * Create a Yoto account client
+      * @param {YotoAccountOptions} options - Account configuration options
+      */
+    constructor(options: YotoAccountOptions);
+    /**
+     * Get the underlying YotoClient instance
+     * @returns {YotoClient}
+     */
+    get client(): YotoClient;
+    /**
+     * Get all device models managed by this account
+     * @returns {Map<string, YotoDeviceModel>}
+     */
+    get devices(): Map<string, YotoDeviceModel>;
+    /**
+     * Check if account is currently running
+     * @returns {boolean}
+     */
+    get running(): boolean;
+    /**
+     * Check if account has been initialized
+     * @returns {boolean}
+     */
+    get initialized(): boolean;
+    /**
+     * Get a specific device by ID
+     * @param {string} deviceId - Device ID
+     * @returns {YotoDeviceModel | undefined}
+     */
+    getDevice(deviceId: string): YotoDeviceModel | undefined;
+    /**
+     * Get all device IDs
+     * @returns {string[]}
+     */
+    getDeviceIds(): string[];
+    /**
+     * Start the account client - creates YotoClient, discovers devices, starts all device clients
+     * @returns {Promise<void>}
+     * @throws {Error} If start fails
+     */
+    start(): Promise<void>;
+    /**
+     * Stop the account client - stops all device clients
+     * @returns {Promise<void>}
+     */
+    stop(): Promise<void>;
+    /**
+     * Restart the account client - stops and starts again
+     * @returns {Promise<void>}
+     */
+    restart(): Promise<void>;
+    /**
+     * Refresh device list - discovers new devices and removes missing ones
+     * @returns {Promise<void>}
+     */
+    refreshDevices(): Promise<void>;
+    #private;
+}
+/**
+ * Yoto Account initialization options
+ */
+export type YotoAccountOptions = {
+    /**
+     * - Yoto API client Options
+     */
+    clientOptions: YotoClientConstructorOptions;
+    /**
+     * - Yoto Device Model Options
+     */
+    deviceOptions: YotoDeviceModelOptions;
+};
+/**
+ * Error context information
+ */
+export type YotoAccountErrorContext = {
+    /**
+     * - Error source ('account', 'client', or deviceId)
+     */
+    source: string;
+    /**
+     * - Device ID if error is device-specific
+     */
+    deviceId?: string;
+    /**
+     * - Operation that failed
+     */
+    operation?: string;
+};
+/**
+ * Started event metadata
+ */
+export type YotoAccountStartedMetadata = {
+    /**
+     * - Number of devices managed
+     */
+    deviceCount: number;
+    /**
+     * - Array of device IDs
+     */
+    devices: string[];
+};
+/**
+ * Event map for YotoAccount
+ */
+export type YotoAccountEventMap = {
+    "started": [YotoAccountStartedMetadata];
+    "stopped": [];
+    "deviceAdded": [string, YotoDeviceModel];
+    "deviceRemoved": [string];
+    "error": [Error, YotoAccountErrorContext];
+};
+import { EventEmitter } from 'events';
+import { YotoClient } from './api-client.js';
+import { YotoDeviceModel } from './yoto-device.js';
+import type { YotoClientConstructorOptions } from './api-client.js';
+import type { YotoDeviceModelOptions } from './yoto-device.js';
+//# sourceMappingURL=yoto-account.d.ts.map

package/lib/yoto-account.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"yoto-account.d.ts","sourceRoot":"","sources":["yoto-account.js"],"names":[],"mappings":"AAaA;;;;;GAKG;AAEH;;;;;;GAMG;AAEH;;;;;GAKG;AAEH;;;;;;;;;GASG;AAMH;;;;;;;;;;;;;;GAcG;AACH;IAOE;;;QAGI;IACJ,qBAFY,kBAAkB,EAS7B;IAMD;;;OAGG;IACH,cAFa,UAAU,CAEc;IAErC;;;OAGG;IACH,eAFa,GAAG,CAAC,MAAM,EAAE,eAAe,CAAC,CAEF;IAEvC;;;OAGG;IACH,eAFa,OAAO,CAEmB;IAEvC;;;OAGG;IACH,mBAFa,OAAO,CAE2B;IAE/C;;;;OAIG;IACH,oBAHW,MAAM,GACJ,eAAe,GAAG,SAAS,CAEmB;IAE3D;;;OAGG;IACH,gBAFa,MAAM,EAAE,CAEsC;IAM3D;;;;OAIG;IACH,SAHa,OAAO,CAAC,IAAI,CAAC,CAyDzB;IAED;;;OAGG;IACH,QAFa,OAAO,CAAC,IAAI,CAAC,CAwCzB;IAED;;;OAGG;IACH,WAFa,OAAO,CAAC,IAAI,CAAC,CAKzB;IAED;;;OAGG;IACH,kBAFa,OAAO,CAAC,IAAI,CAAC,CAwEzB;;CAqBF;;;;;;;;mBAnUa,4BAA4B;;;;mBAC5B,sBAAsB;;;;;;;;;YAMtB,MAAM;;;;eACN,MAAM;;;;gBACN,MAAM;;;;;;;;;iBAMN,MAAM;;;;aACN,MAAM,EAAE;;;;;kCAKT;IACZ,SAAa,EAAE,CAAC,0BAA0B,CAAC,CAAC;IAC5C,SAAa,EAAE,EAAE,CAAC;IAClB,aAAiB,EAAE,CAAC,MAAM,EAAE,eAAe,CAAC,CAAC;IAC7C,eAAmB,EAAE,CAAC,MAAM,CAAC,CAAC;IAC9B,OAAW,EAAE,CAAC,KAAK,EAAE,uBAAuB,CAAC,CAAA;CAC1C;6BAtCyB,QAAQ;2BACV,iBAAiB;gCACZ,kBAAkB;kDAND,iBAAiB;4CACvB,kBAAkB"}