yoto-nodejs-client 0.0.1 → 0.0.3

package/lib/mqtt/factory.d.ts

@@ -1,12 +1,73 @@
+/**
+ * Create a configured MQTT client for a Yoto device
+ * @param {YotoMqttOptions} options - MQTT connection options
+ * @returns {YotoMqttClient} Configured Yoto MQTT client
+ * @throws {Error} If required options are missing
+ *
+ * @example
+ * ```javascript
+ * import { createYotoMqttClient } from 'yoto-nodejs-client/lib/mqtt'
+ *
+ * const client = createYotoMqttClient({
+ *   deviceId: 'abc123',
+ *   accessToken: 'eyJhbGc...'
+ * })
+ *
+ * client.on('events', (message) => {
+ *   console.log('Playing:', message.trackTitle)
+ * })
+ *
+ * await client.connect()
+ * ```
+ *
+ * @example
+ * ```javascript
+ * // Disable automatic reconnection
+ * const client = createYotoMqttClient({
+ *   deviceId: 'abc123',
+ *   accessToken: 'token',
+ *   mqttOptions: {
+ *     reconnectPeriod: 0,     // Disable auto-reconnect (default is 5000ms)
+ *     connectTimeout: 30000   // 30 second connection timeout
+ *   }
+ * })
+ * ```
+ */
 export function createYotoMqttClient(options: YotoMqttOptions): YotoMqttClient;
+/**
+ * MQTT.js client options that can be passed to createYotoMqttClient
+ */
+export type MqttClientOptions = Partial<mqtt.IClientOptions>;
 export type YotoMqttOptions = {
+    /**
+     * - Device ID to connect to
+     */
     deviceId: string;
+    /**
+     * - JWT access token for authentication
+     */
     accessToken: string;
+    /**
+     * - Prefix for MQTT client ID (default: 'DASH')
+     */
     clientIdPrefix?: string;
+    /**
+     * - MQTT broker URL
+     */
     brokerUrl?: string;
-    keepalive?: number;
+    /**
+     * - MQTT broker port
+     */
     port?: number;
+    /**
+     * - Auto-subscribe to device topics on connect
+     */
     autoSubscribe?: boolean;
+    /**
+     * - Additional MQTT.js client options (defaults: reconnectPeriod=5000, keepalive=300; cannot override: clientId, username, password, protocol, ALPNProtocols)
+     */
+    mqttOptions?: MqttClientOptions;
 };
 import { YotoMqttClient } from './client.js';
+import mqtt from 'mqtt';
 //# sourceMappingURL=factory.d.ts.map

package/lib/mqtt/factory.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"factory.d.ts","sourceRoot":"","sources":["factory.js"],"names":[],"mappings":"AA2DA,8CApBW,eAAe,GACb,cAAc,CAkE1B;;cAzFa,MAAM;iBACN,MAAM;qBACN,MAAM;gBACN,MAAM;gBACN,MAAM;WACN,MAAM;oBACN,OAAO;;+BAIU,aAAa"}
+{"version":3,"file":"factory.d.ts","sourceRoot":"","sources":["factory.js"],"names":[],"mappings":"AA0CA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,8CAjCW,eAAe,GACb,cAAc,CAmF1B;;;;gCA/GY,OAAO,CAAC,mBAAc,CAAC;;;;;cAKtB,MAAM;;;;iBACN,MAAM;;;;qBACN,MAAM;;;;gBACN,MAAM;;;;WACN,MAAM;;;;oBACN,OAAO;;;;kBACP,iBAAiB;;+BAIA,aAAa;iBAD3B,MAAM"}

package/lib/mqtt/factory.js

@@ -13,15 +13,20 @@
 // MQTT Factory: Create properly configured MQTT clients for Yoto devices
 // ============================================================================
 
+/**
+ * MQTT.js client options that can be passed to createYotoMqttClient
+ * @typedef {Partial<IClientOptions>} MqttClientOptions
+ */
+
 /**
  * @typedef {Object} YotoMqttOptions
  * @property {string} deviceId - Device ID to connect to
  * @property {string} accessToken - JWT access token for authentication
  * @property {string} [clientIdPrefix='DASH'] - Prefix for MQTT client ID (default: 'DASH')
  * @property {string} [brokerUrl='wss://aqrphjqbp3u2z-ats.iot.eu-west-2.amazonaws.com'] - MQTT broker URL
- * @property {number} [keepalive=300] - Keepalive interval in seconds
  * @property {number} [port=443] - MQTT broker port
  * @property {boolean} [autoSubscribe=true] - Auto-subscribe to device topics on connect
+ * @property {MqttClientOptions} [mqttOptions] - Additional MQTT.js client options (defaults: reconnectPeriod=5000, keepalive=300; cannot override: clientId, username, password, protocol, ALPNProtocols)
  */
 
 import mqtt from 'mqtt'
@@ -56,6 +61,19 @@ import {
  *
  * await client.connect()
  * ```
+ *
+ * @example
+ * ```javascript
+ * // Disable automatic reconnection
+ * const client = createYotoMqttClient({
+ *   deviceId: 'abc123',
+ *   accessToken: 'token',
+ *   mqttOptions: {
+ *     reconnectPeriod: 0,     // Disable auto-reconnect (default is 5000ms)
+ *     connectTimeout: 30000   // 30 second connection timeout
+ *   }
+ * })
+ * ```
  */
 export function createYotoMqttClient (options) {
   // Validate required options
@@ -73,9 +91,9 @@ export function createYotoMqttClient (options) {
     accessToken,
     clientIdPrefix = 'DASH',
     brokerUrl = MQTT_BROKER_URL,
-    keepalive = MQTT_KEEPALIVE,
     port = MQTT_PORT,
-    autoSubscribe = true
+    autoSubscribe = true,
+    mqttOptions: additionalMqttOptions = {}
   } = options
 
   // Build MQTT client ID
@@ -85,15 +103,19 @@ export function createYotoMqttClient (options) {
   const username = `${deviceId}?x-amz-customauthorizer-name=${MQTT_AUTH_NAME}`
 
   // Create MQTT connection options
+  // Merge additional options first, then override with required Yoto settings
   /** @type {IClientOptions} */
   const mqttOptions = {
+    // Defaults (can be overridden by additionalMqttOptions)
+    reconnectPeriod: 5000, // Default: auto-reconnect after 5 seconds
+    keepalive: MQTT_KEEPALIVE, // Default: 300 seconds (5 minutes)
+    ...additionalMqttOptions, // Allow overriding defaults
+    // Required Yoto-specific settings (cannot be overridden)
     clientId,
     username,
     password: accessToken,
-    keepalive,
     port,
     protocol: MQTT_PROTOCOL,
-    reconnectPeriod: 0, // Disable auto-reconnect, handle manually
     ALPNProtocols: MQTT_ALPN_PROTOCOLS
   }
 

package/lib/mqtt/mqtt.test.js

@@ -1,13 +1,13 @@
 import test from 'node:test'
 import assert from 'node:assert'
 import { getDevices } from '../api-endpoints/devices.js'
-import { loadTestTokens, logResponse } from '../api-endpoints/test-helpers.js'
+import { loadTestTokens, logResponse } from '../api-endpoints/endpoint-test-helpers.js'
 import { createYotoMqttClient } from './index.js'
 
 const { accessToken } = loadTestTokens()
 
 test('MQTT client', async (t) => {
-  await t.test('should connect, request status/events, and receive response and events messages', async () => {
+  await t.test('should connect, request status/events, and receive response and events messages (status-legacy is optional)', async () => {
     // Get an online device
     const response = await getDevices({ accessToken })
     assert.ok(response.devices.length > 0, 'Should have at least one device')
@@ -28,23 +28,26 @@ test('MQTT client', async (t) => {
     let eventsResponseReceived = false
     let eventsMessageReceived = false
     let statusMessageReceived = false
+    let statusLegacyMessageReceived = false
     /** @type {Error[]} */
     const errors = []
 
     // Setup message handlers
-    mqttClient.on('events', (message) => {
-      logResponse('MQTT events message', message)
+    mqttClient.on('events', (topic, payload) => {
+      logResponse('MQTT events message', { topic, payload })
 
       try {
         // Validate events message structure
-        assert.ok(message, 'Events message should exist')
+        assert.ok(payload, 'Events message should exist')
+        assert.ok(typeof topic === 'string', 'Topic should be a string')
+        assert.ok(topic.includes('/data/events'), 'Topic should contain /data/events')
 
         // Events messages are partial - not all fields are always present
-        if (message.playbackStatus !== undefined) {
-          assert.ok(typeof message.playbackStatus === 'string', 'playbackStatus should be string')
+        if (payload.playbackStatus !== undefined) {
+          assert.ok(typeof payload.playbackStatus === 'string', 'playbackStatus should be string')
         }
-        if (message.cardId !== undefined) {
-          assert.ok(typeof message.cardId === 'string', 'cardId should be string')
+        if (payload.cardId !== undefined) {
+          assert.ok(typeof payload.cardId === 'string', 'cardId should be string')
         }
 
         eventsMessageReceived = true
@@ -53,18 +56,20 @@ test('MQTT client', async (t) => {
       }
     })
 
-    mqttClient.on('status', (message) => {
-      logResponse('MQTT status message', message)
+    mqttClient.on('status', (topic, payload) => {
+      logResponse('MQTT status message', { topic, payload })
 
       try {
         // Validate status message structure
-        assert.ok(message, 'Status message should exist')
-        assert.ok(message.status, 'Status message should have status object')
-        assert.ok(typeof message.status.statusVersion === 'number', 'Should have statusVersion number')
-        assert.ok(typeof message.status.fwVersion === 'string', 'Should have fwVersion string')
-        assert.ok(typeof message.status.productType === 'string', 'Should have productType string')
-        assert.ok(typeof message.status.batteryLevel === 'number', 'Should have batteryLevel number')
-        assert.ok(typeof message.status.volume === 'number', 'Should have volume number')
+        assert.ok(payload, 'Status message should exist')
+        assert.ok(typeof topic === 'string', 'Topic should be a string')
+        assert.ok(topic.includes('/data/status'), 'Topic should contain /data/status')
+        assert.ok(payload.status, 'Status message should have status object')
+        assert.ok(typeof payload.status.statusVersion === 'number', 'Should have statusVersion number')
+        assert.ok(typeof payload.status.fwVersion === 'string', 'Should have fwVersion string')
+        assert.ok(typeof payload.status.productType === 'string', 'Should have productType string')
+        assert.ok(typeof payload.status.batteryLevel === 'number', 'Should have batteryLevel number')
+        assert.ok(typeof payload.status.volume === 'number', 'Should have volume number')
 
         statusMessageReceived = true
       } catch (err) {
@@ -72,28 +77,71 @@ test('MQTT client', async (t) => {
       }
     })
 
-    mqttClient.on('response', (message) => {
-      logResponse('MQTT response message', message)
+    mqttClient.on('status-legacy', (topic, payload) => {
+      logResponse('MQTT status-legacy message', { topic, payload })
+
+      try {
+        // Validate legacy status message structure
+        assert.ok(payload, 'Legacy status message should exist')
+        assert.ok(typeof topic === 'string', 'Topic should be a string')
+        assert.ok(!topic.includes('/data/'), 'Legacy topic should NOT contain /data/')
+        assert.ok(payload.status, 'Legacy status message should have status object')
+
+        // Validate lifecycle fields unique to legacy format
+        assert.ok(typeof payload.status.statusVersion === 'number', 'Should have statusVersion number')
+        assert.ok(typeof payload.status.fwVersion === 'string', 'Should have fwVersion string')
+
+        // shutDown field is the key field for lifecycle events
+        if (payload.status.shutDown !== undefined) {
+          assert.ok(typeof payload.status.shutDown === 'string', 'shutDown should be string')
+        }
+
+        // upTime and utcTime are key for startup detection
+        if (payload.status.upTime !== undefined) {
+          assert.ok(typeof payload.status.upTime === 'number', 'upTime should be number')
+        }
+        if (payload.status.utcTime !== undefined) {
+          assert.ok(typeof payload.status.utcTime === 'number', 'utcTime should be number')
+        }
+
+        // Hardware diagnostic fields unique to legacy
+        if (payload.status.battery !== undefined) {
+          assert.ok(typeof payload.status.battery === 'number', 'battery should be number')
+        }
+        if (payload.status.wifiStrength !== undefined) {
+          assert.ok(typeof payload.status.wifiStrength === 'number', 'wifiStrength should be number')
+        }
+
+        statusLegacyMessageReceived = true
+      } catch (err) {
+        errors.push(/** @type {Error} */ (err))
+      }
+    })
+
+    mqttClient.on('response', (topic, payload) => {
+      logResponse('MQTT response message', { topic, payload })
 
       try {
         // Validate response message structure
-        assert.ok(message, 'Response message should exist')
-        assert.ok(message.status, 'Response should have status object')
-        assert.ok(typeof message.status.req_body === 'string', 'Response should have req_body string')
+        assert.ok(payload, 'Response message should exist')
+        assert.ok(typeof topic === 'string', 'Topic should be a string')
+        assert.ok(topic.includes('/response'), 'Topic should contain /response')
+        assert.ok(payload.status, 'Response should have status object')
+        assert.ok(typeof payload.status.req_body === 'string', 'Response should have req_body string')
 
         // Check if status request was acknowledged (field name is 'status/request')
-        if (message.status['status/request']) {
+        if (payload.status['status/request']) {
           assert.ok(
-            message.status['status/request'] === 'OK' || message.status['status/request'] === 'FAIL',
+            payload.status['status/request'] === 'OK' || payload.status['status/request'] === 'FAIL',
             'Status request field should be OK or FAIL'
           )
           statusResponseReceived = true
         }
 
         // Check if events request was acknowledged
-        if (message.status.events) {
+        if (payload.status.events) {
           assert.ok(
-            message.status.events === 'OK' || message.status.events === 'FAIL',
+            payload.status.events === 'OK' || payload.status.events === 'FAIL',
             'Events request field should be OK or FAIL'
           )
           eventsResponseReceived = true
@@ -125,7 +173,7 @@ test('MQTT client', async (t) => {
       // Wait for messages (with timeout)
       await new Promise((resolve, reject) => {
         timeoutId = setTimeout(() => {
-          reject(new Error(`Timeout waiting for messages. statusResponse=${statusResponseReceived}, eventsResponse=${eventsResponseReceived}, eventsMessage=${eventsMessageReceived}, statusMessage=${statusMessageReceived}`))
+          reject(new Error(`Timeout waiting for messages. statusResponse=${statusResponseReceived}, eventsResponse=${eventsResponseReceived}, eventsMessage=${eventsMessageReceived}, statusMessage=${statusMessageReceived}, statusLegacy=${statusLegacyMessageReceived} (optional)`))
         }, 5000) // 5 second timeout
 
         checkIntervalId = setInterval(() => {
@@ -134,6 +182,8 @@ test('MQTT client', async (t) => {
             clearInterval(checkIntervalId)
             reject(errors[0])
           }
+          // Note: status-legacy is NOT required - it doesn't respond to requestStatus()
+          // It only emits on real-time lifecycle events (shutdown/startup) or 5-minute periodic updates
           if (statusResponseReceived && eventsResponseReceived && eventsMessageReceived && statusMessageReceived) {
             clearTimeout(timeoutId)
             clearInterval(checkIntervalId)
@@ -147,6 +197,13 @@ test('MQTT client', async (t) => {
       assert.ok(eventsResponseReceived, 'Should have received events request response')
       assert.ok(eventsMessageReceived, 'Should have received events data message')
       assert.ok(statusMessageReceived, 'Should have received status data message')
+
+      // Note: status-legacy message is optional in this test because it does NOT respond to requestStatus()
+      // It only emits on real-time lifecycle events (shutdown/startup) or 5-minute periodic updates
+      // If we happened to catch one during the test window, validate it was received correctly
+      if (statusLegacyMessageReceived) {
+        console.log('✓ Received optional status-legacy message with lifecycle events')
+      }
     } catch (err) {
       // Clean up timers on error
       if (timeoutId) clearTimeout(timeoutId)

package/lib/mqtt/topics.d.ts

@@ -1,34 +1,219 @@
+/**
+ * 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
+ */
 export function getEventsTopic(deviceId: string): string[];
+/**
+ * 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 (both documented and legacy)
+ */
 export function getStatusTopic(deviceId: string): string[];
+/**
+ * Get the response topic for a device (subscribe)
+ * @param {string} deviceId - Device ID
+ * @returns {string} Response topic
+ */
 export function getResponseTopic(deviceId: string): string;
+/**
+ * Get all subscription topics for a device
+ *
+ * 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)
+ *
+ * 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
+ */
 export function getSubscriptionTopics(deviceId: string): string[];
+/**
+ * Get a command topic for a device (publish)
+ * @param {string} deviceId - Device ID
+ * @param {string} resource - Command resource (e.g., 'volume', 'ambients', 'card')
+ * @param {string} [action] - Command action (e.g., 'set', 'start', 'stop')
+ * @returns {string} Command topic
+ */
 export function getCommandTopic(deviceId: string, resource: string, action?: string): string;
+/**
+ * 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
+ */
 export function parseTopic(topic: string): {
     deviceId: string;
     messageType: YotoMqttTopicType | "unknown";
 };
+/**
+ * Get the events request command topic
+ * @param {string} deviceId - Device ID
+ * @returns {string} Events request topic
+ */
 export function getEventsRequestTopic(deviceId: string): string;
+/**
+ * Get the status request command topic
+ * @param {string} deviceId - Device ID
+ * @returns {string} Status request topic
+ */
 export function getStatusRequestTopic(deviceId: string): string;
+/**
+ * Get the volume set command topic
+ * @param {string} deviceId - Device ID
+ * @returns {string} Volume set topic
+ */
 export function getVolumeSetTopic(deviceId: string): string;
+/**
+ * Get the ambients set command topic
+ * @param {string} deviceId - Device ID
+ * @returns {string} Ambients set topic
+ */
 export function getAmbientsSetTopic(deviceId: string): string;
+/**
+ * Get the sleep timer set command topic
+ * @param {string} deviceId - Device ID
+ * @returns {string} Sleep timer set topic
+ */
 export function getSleepTimerSetTopic(deviceId: string): string;
+/**
+ * Get the reboot command topic
+ * @param {string} deviceId - Device ID
+ * @returns {string} Reboot topic
+ */
 export function getRebootTopic(deviceId: string): string;
+/**
+ * Get the card start command topic
+ * @param {string} deviceId - Device ID
+ * @returns {string} Card start topic
+ */
 export function getCardStartTopic(deviceId: string): string;
+/**
+ * Get the card stop command topic
+ * @param {string} deviceId - Device ID
+ * @returns {string} Card stop topic
+ */
 export function getCardStopTopic(deviceId: string): string;
+/**
+ * Get the card pause command topic
+ * @param {string} deviceId - Device ID
+ * @returns {string} Card pause topic
+ */
 export function getCardPauseTopic(deviceId: string): string;
+/**
+ * Get the card resume command topic
+ * @param {string} deviceId - Device ID
+ * @returns {string} Card resume topic
+ */
 export function getCardResumeTopic(deviceId: string): string;
+/**
+ * Get the bluetooth on command topic
+ * @param {string} deviceId - Device ID
+ * @returns {string} Bluetooth on topic
+ */
 export function getBluetoothOnTopic(deviceId: string): string;
+/**
+ * Get the bluetooth off command topic
+ * @param {string} deviceId - Device ID
+ * @returns {string} Bluetooth off topic
+ */
 export function getBluetoothOffTopic(deviceId: string): string;
+/**
+ * Get the bluetooth delete bonds command topic
+ * @param {string} deviceId - Device ID
+ * @returns {string} Bluetooth delete bonds topic
+ */
 export function getBluetoothDeleteBondsTopic(deviceId: string): string;
+/**
+ * Get the bluetooth connect command topic
+ * @param {string} deviceId - Device ID
+ * @returns {string} Bluetooth connect topic
+ */
 export function getBluetoothConnectTopic(deviceId: string): string;
+/**
+ * Get the bluetooth disconnect command topic
+ * @param {string} deviceId - Device ID
+ * @returns {string} Bluetooth disconnect topic
+ */
 export function getBluetoothDisconnectTopic(deviceId: string): string;
+/**
+ * Get the bluetooth state command topic
+ * @param {string} deviceId - Device ID
+ * @returns {string} Bluetooth state topic
+ */
 export function getBluetoothStateTopic(deviceId: string): string;
+/**
+ * Get the display preview command topic
+ * @param {string} deviceId - Device ID
+ * @returns {string} Display preview topic
+ */
 export function getDisplayPreviewTopic(deviceId: string): string;
+/**
+ * MQTT Topics for Yoto Players
+ *
+ * Topic builders and constants for Yoto MQTT communication
+ * @see https://yoto.dev/players-mqtt/
+ */
+/**
+ * MQTT topic type for subscriptions
+ * @typedef {'events' | 'status' | 'status-legacy' | 'response'} YotoMqttTopicType
+ */
+/**
+ * MQTT broker URL for Yoto devices
+ */
 export const MQTT_BROKER_URL: "wss://aqrphjqbp3u2z-ats.iot.eu-west-2.amazonaws.com";
+/**
+ * MQTT authorizer name for Yoto authentication
+ */
 export const MQTT_AUTH_NAME: "PublicJWTAuthorizer";
+/**
+ * MQTT connection port
+ */
 export const MQTT_PORT: 443;
+/**
+ * MQTT protocol
+ */
 export const MQTT_PROTOCOL: "wss";
+/**
+ * MQTT keepalive interval in seconds
+ */
 export const MQTT_KEEPALIVE: 300;
+/**
+ * ALPN protocols for AWS IoT
+ */
 export const MQTT_ALPN_PROTOCOLS: string[];
-export type YotoMqttTopicType = "events" | "status" | "response";
+/**
+ * MQTT topic type for subscriptions
+ */
+export type YotoMqttTopicType = "events" | "status" | "status-legacy" | "response";
 //# sourceMappingURL=topics.d.ts.map

package/lib/mqtt/topics.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"topics.d.ts","sourceRoot":"","sources":["topics.js"],"names":[],"mappings":"AAoDA,yCAHW,MAAM,GACJ,MAAM,EAAE,CAOpB;AAQD,yCAHW,MAAM,GACJ,MAAM,EAAE,CAOpB;AAOD,2CAHW,MAAM,GACJ,MAAM,CAIlB;AAcD,gDAHW,MAAM,GACJ,MAAM,EAAE,CAQpB;AASD,0CALW,MAAM,YACN,MAAM,WACN,MAAM,GACJ,MAAM,CAKlB;AAOD,kCAHW,MAAM,GACJ;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,iBAAiB,GAAG,SAAS,CAAA;CAAE,CAuB5E;AASD,gDAHW,MAAM,GACJ,MAAM,CAIlB;AAOD,gDAHW,MAAM,GACJ,MAAM,CAIlB;AAOD,4CAHW,MAAM,GACJ,MAAM,CAIlB;AAOD,8CAHW,MAAM,GACJ,MAAM,CAIlB;AAOD,gDAHW,MAAM,GACJ,MAAM,CAIlB;AAOD,yCAHW,MAAM,GACJ,MAAM,CAIlB;AAOD,4CAHW,MAAM,GACJ,MAAM,CAIlB;AAOD,2CAHW,MAAM,GACJ,MAAM,CAIlB;AAOD,4CAHW,MAAM,GACJ,MAAM,CAIlB;AAOD,6CAHW,MAAM,GACJ,MAAM,CAIlB;AAOD,8CAHW,MAAM,GACJ,MAAM,CAIlB;AAOD,+CAHW,MAAM,GACJ,MAAM,CAIlB;AAOD,uDAHW,MAAM,GACJ,MAAM,CAIlB;AAOD,mDAHW,MAAM,GACJ,MAAM,CAIlB;AAOD,sDAHW,MAAM,GACJ,MAAM,CAIlB;AAOD,iDAHW,MAAM,GACJ,MAAM,CAIlB;AAOD,iDAHW,MAAM,GACJ,MAAM,CAIlB;AAnRD,8BAA+B,qDAAqD,CAAA;AAKpF,6BAA8B,qBAAqB,CAAA;AAKnD,wBAAyB,GAAG,CAAA;AAK5B,4BAA6B,KAAK,CAAA;AAKlC,6BAA8B,GAAG,CAAA;AAKjC,2CAAqD;gCA/BxC,QAAQ,GAAG,QAAQ,GAAG,UAAU"}
+{"version":3,"file":"topics.d.ts","sourceRoot":"","sources":["topics.js"],"names":[],"mappings":"AA8CA;;;;;;;;GAQG;AACH,yCAHW,MAAM,GACJ,MAAM,EAAE,CAOpB;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,yCAHW,MAAM,GACJ,MAAM,EAAE,CAOpB;AAED;;;;GAIG;AACH,2CAHW,MAAM,GACJ,MAAM,CAIlB;AAED;;;;;;;;;;;;;;;GAeG;AACH,gDAHW,MAAM,GACJ,MAAM,EAAE,CAQpB;AAED;;;;;;GAMG;AACH,0CALW,MAAM,YACN,MAAM,WACN,MAAM,GACJ,MAAM,CAKlB;AAED;;;;;;;;;GASG;AACH,kCAHW,MAAM,GACJ;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,iBAAiB,GAAG,SAAS,CAAA;CAAE,CA6B5E;AAID;;;;GAIG;AACH,gDAHW,MAAM,GACJ,MAAM,CAIlB;AAED;;;;GAIG;AACH,gDAHW,MAAM,GACJ,MAAM,CAIlB;AAED;;;;GAIG;AACH,4CAHW,MAAM,GACJ,MAAM,CAIlB;AAED;;;;GAIG;AACH,8CAHW,MAAM,GACJ,MAAM,CAIlB;AAED;;;;GAIG;AACH,gDAHW,MAAM,GACJ,MAAM,CAIlB;AAED;;;;GAIG;AACH,yCAHW,MAAM,GACJ,MAAM,CAIlB;AAED;;;;GAIG;AACH,4CAHW,MAAM,GACJ,MAAM,CAIlB;AAED;;;;GAIG;AACH,2CAHW,MAAM,GACJ,MAAM,CAIlB;AAED;;;;GAIG;AACH,4CAHW,MAAM,GACJ,MAAM,CAIlB;AAED;;;;GAIG;AACH,6CAHW,MAAM,GACJ,MAAM,CAIlB;AAED;;;;GAIG;AACH,8CAHW,MAAM,GACJ,MAAM,CAIlB;AAED;;;;GAIG;AACH,+CAHW,MAAM,GACJ,MAAM,CAIlB;AAED;;;;GAIG;AACH,uDAHW,MAAM,GACJ,MAAM,CAIlB;AAED;;;;GAIG;AACH,mDAHW,MAAM,GACJ,MAAM,CAIlB;AAED;;;;GAIG;AACH,sDAHW,MAAM,GACJ,MAAM,CAIlB;AAED;;;;GAIG;AACH,iDAHW,MAAM,GACJ,MAAM,CAIlB;AAED;;;;GAIG;AACH,iDAHW,MAAM,GACJ,MAAM,CAIlB;AAxUD;;;;;GAKG;AAMH;;;GAGG;AAEH;;GAEG;AACH,8BAA+B,qDAAqD,CAAA;AAEpF;;GAEG;AACH,6BAA8B,qBAAqB,CAAA;AAEnD;;GAEG;AACH,wBAAyB,GAAG,CAAA;AAE5B;;GAEG;AACH,4BAA6B,KAAK,CAAA;AAElC;;GAEG;AACH,6BAA8B,GAAG,CAAA;AAEjC;;GAEG;AACH,2CAAqD;;;;gCA/BxC,QAAQ,GAAG,QAAQ,GAAG,eAAe,GAAG,UAAU"}