jooby-codec 3.15.0 → 7.0.1

package/readme.md

@@ -15,25 +15,31 @@ Install required dependencies:
 npm install jooby-codec
 ```
 
-This will provide 2 classes of codecs:
+This will provide 4 protocols of codecs:
 
-- analog
-- OBIS observer
+- Analog
+- MTX1
+- MTX3
+- OBIS Observer
 
+There is a low-level documentation available in a separate [repository](https://github.com/jooby-dev/jooby-docs).
 
-## Usage of analog codecs
+It's also possible to send MTX commands [via Lora](./mtx-lora.md).
+
+
+## Usage of Analog codecs
 
 Add to the project:
 
 ```js
 import {commands, message} from 'jooby-codec/analog';
 
-// output all available commands tree
+// output all available downlink and uplink commands tree
 console.log(commands);
 // all uplink commands
 console.log(commands.uplink);
 // one particular command
-console.log(commands.uplink.CurrentMC);
+console.log(commands.uplink.correctTime2000);
 
 // output main namespace for work with messages
 console.log(message);
@@ -48,124 +54,454 @@ import {downlink} from 'jooby-codec/analog/commands';
 import * as downlink from 'jooby-codec/analog/commands/downlink';
 
 // to get one particular command
-import SetTime2000 from 'jooby-codec/analog/commands/downlink/SetTime2000.js';
+import * as setTime2000 from 'jooby-codec/analog/commands/downlink/setTime2000.js';
 ```
 
 The last approach is preferred as it is more efficient and will init only a necessary commands.
 
-It's possible to parse messages either from raw [Uint8Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array) or HEX string:
-
-Parse downlink message:
+Prepare and parse downlink message:
 
 ```js
-import {directions, hardwareTypes} from 'jooby-codec/analog/constants';
-
-// from byte array
-const messageData = message.fromBytes(
-    new Uint8Array([
-        0x02, 0x05, 0x4e, 0x00, 0x01, 0xe2, 0x40,
-        0x02, 0x05, 0x4e, 0x00, 0x01, 0xe2, 0x40,
-        0x55
-    ]),
-    directions.DOWNLINK
-);
-// or from hex string
-const messageData = message.fromHex(
-    '02 05 4e 00 01 e2 40  02 05 4e 00 01 e2 40  55',
-    directions.DOWNLINK
-);
+import * as message from 'jooby-codec/analog/message/downlink';
+import * as downlinkCommands from 'jooby-codec/analog/commands/downlink';
+import getHexFromBytes from 'jooby-codec/utils/getHexFromBytes.js';
+
+const commands = [
+    {
+        id: downlinkCommands.correctTime2000.id,
+        parameters: {sequenceNumber: 45, seconds: -120}
+    }
+];
+const bytes = message.toBytes(commands);
+
+console.log('message encoded:', JSON.stringify(bytes));
+// output:
+[12,2,45,136,254]
 
-// decoded data with commands and checksum
-console.log(messageData);
-/*{
+console.log('message encoded in HEX:', getHexFromBytes(bytes));
+// output:
+'0c 02 2d 88 fe'
+
+// decode message back from bytes
+const parsedMessage = message.fromBytes(bytes);
+
+console.log('parsedMessage:', parsedMessage);
+// output:
+{
     commands: [
-        { data: [Object], command: [SetTime2000] },
-        { data: [Object], command: [SetTime2000] }
+      {
+        id: 12,
+        name: 'correctTime2000',
+        headerSize: 2,
+        bytes: [Array],
+        parameters: [Object]
+      }
     ],
-    lrc: { expected: 85, actual: 85 },
-    isValid: true
-}*/
+    bytes: [ 12, 2, 45, 136, 254 ],
+    lrc: { received: 254, calculated: 254 }
+}
 ```
 
 Parse uplink message:
 
 ```js
-const messageData = message.fromHex(
-    '02 01 01  18 06 0f 83 01 08 0a 0c  16 08 2f 97 0f 83 01 08 0a 0c  ef',
-    directions.UPLINK
-);
+import * as message from 'jooby-codec/analog/message/uplink';
+
+// binary data received from a device
+const bytes = [0x0c, 0x01, 0x00, 0x58];
+
+// decode it
+const payload = message.fromBytes(bytes);
+
+if ( 'error' in payload ) {
+    console.log('decode failure:', payload.error, payload.message);
+} else {
+    console.log('message decoded:', payload.commands);
+    // output:
+    [
+        {
+            id: 12,
+            headerSize: 2,
+            bytes: [ 12, 1, 0 ],
+            parameters: { status: 0 }
+        }
+    ]
+}
+```
+
+There may be necessary to pass an additional config with hardware type:
+
+```js
+import * as message from 'jooby-codec/analog/message/uplink';
+import * as hardwareTypes from 'jooby-codec/analog/constants/hardwareTypes.js';
+
+// binary data received from a device
+const bytes = [0x62, 0x20, 0x09, 0x1e];
+
+const config = {
+    hardwareType: hardwareTypes.GASI3
+};
+
+// decode it
+const payload = message.fromBytes(bytes, config);
+
+if ( 'error' in payload ) {
+    console.log('decode failure:', payload.error, payload.message);
+} else {
+    console.log('message decoded:', payload.commands[0]);
+    // output:
+    [
+        {
+            id: 96,
+            name: 'lastEvent',
+            headerSize: 1,
+            bytes: [98, 32, 9],
+            config: {hardwareType: 3},
+            parameters: {
+                sequenceNumber: 32,
+                status: {
+                    isBatteryLow: true,
+                    isMagneticInfluence: false,
+                    isButtonReleased: false,
+                    isConnectionLost: true
+                }
+            }
+        }
+    ]
+}
 ```
 
-It's possible to parse message with autodetect direction:
+
+## Usage of MTX codecs
+
+Add to the project:
+
+```js
+import {commands, message} from 'jooby-codec/mtx1';
+
+// output all available downlink and uplink commands tree
+console.log(commands);
+// all uplink commands
+console.log(commands.uplink);
+// one particular command
+console.log(commands.uplink.setDateTime);
+
+// output main namespace for work with messages
+console.log(message);
+```
+
+But it's better to add only necessary commands to the project:
+
+```js
+// to get only downlink commands
+import {downlink} from 'jooby-codec/mtx1/commands';
+// or slightly more efficient
+import * as downlink from 'jooby-codec/mtx1/commands/downlink';
+
+// to get one particular command
+import * as setDateTime from 'jooby-codec/mtx1/commands/downlink/setDateTime.js';
+```
+
+The last approach is preferred as it is more efficient and will init only a necessary commands.
+
+Prepare and parse downlink message and frame:
 
 ```js
-// It is highly recommended to use a specific direction.
-// AUTO is used here just for example.
-const messageData = message.fromHex(
-    '02 01 01  18 06 0f 83 01 08 0a 0c  16 08 2f 97 0f 83 01 08 0a 0c  ef',
-    directions.AUTO
+import * as message from 'jooby-codec/mtx1/message/downlink';
+import * as frame from 'jooby-codec/mtx1/utils/frame.js';
+import * as downlinkCommands from 'jooby-codec/mtx1/commands/downlink';
+import getHexFromBytes from 'jooby-codec/utils/getHexFromBytes.js';
+import * as frameTypes from 'jooby-codec/mtx1/constants/frameTypes.js';
+
+const aesKey = [...Array(16).keys()];
+const messageId = 10;
+
+const commands = [
+    {
+        id: downlinkCommands.setDateTime.id,
+        parameters: {
+            isSummerTime: false,
+            seconds: 55,
+            minutes: 31,
+            hours: 18,
+            day: 2,
+            date: 19,
+            month: 2,
+            year: 24
+        }
+    }
+];
+const messageBytes = message.toBytes(
+    commands,
+    {
+        messageId,
+        accessLevel: downlinkCommands.setDateTime.accessLevel,
+        aesKey
+    }
 );
-// or even shorter as message.TYPE_AUTO is default behavior
-const messageData = message.fromHex(
-    '02 01 01  18 06 0f 83 01 08 0a 0c  16 08 2f 97 0f 83 01 08 0a 0c  ef'
+
+console.log('message encoded:', JSON.stringify(messageBytes));
+// output:
+[10,19,237,116,10,174,74,186,200,66,196,27,231,245,13,60,40,132]
+
+console.log('message encoded in HEX:', getHexFromBytes(messageBytes));
+// output:
+'0a 13 ed 74 0a ae 4a ba c8 42 c4 1b e7 f5 0d 3c 28 84'
+
+const frameBytes = frame.toBytes(
+    messageBytes,
+    {
+        type: frameTypes.DATA_REQUEST,
+        source: 0xffff,
+        destination: 0xaaaa
+    }
 );
+
+console.log('frame encoded:', frameBytes);
+// output:
+[126,80,170,170,255,255,10,125,51,237,116,10,174,74,186,200,66,196,27,231,245,13,60,40,132,97,187,126]
+
+console.log('frame encoded in HEX:', getHexFromBytes(frameBytes));
+// output:
+'7e 50 aa aa ff ff 0a 7d 33 ed 74 0a ae 4a ba c8 42 c4 1b e7 f5 0d 3c 28 84 61 bb 7e'
+
+
+// decode message back from bytes
+const parsedMessage = message.fromBytes(messageBytes, {aesKey});
+
+console.log('parsed message:', parsedMessage);
+// output:
+/* {
+    messageId: 3,
+    accessLevel: 3,
+    commands: [
+    {
+        id: 8,
+        name: 'setDateTime',
+        headerSize: 2,
+        bytes: [Array],
+        parameters: [Object]
+    }
+    ],
+    bytes: [3,19,237,116,10,174,74,186,200,66,196,27,231,245,13,60,40,132],
+    lrc: {received: 119, calculated: 119}
+} */
+
+// decode message back from frame
+const parsedFrame = frame.fromBytes(frameBytes);
+
+console.log('parsedFrame:', parsedFrame);
+// output:
+/* {
+    bytes: [10,19,237,116,10,174,74,186,200,66,196,27,231,245,13,60,40,132],
+    crc: {calculated: 47969, received: 47969},
+    header: {type: 80, destination: 43690, source: 65535}
+} */
+
+if ( 'bytes' in parsedFrame ) {
+    const parsedMessage2 = message.fromBytes(parsedFrame.bytes, {aesKey});
+
+    console.log('parsedMessage2:', parsedMessage2);
+    // output:
+    /* {
+        messageId: 10,
+        accessLevel: 3,
+        commands: [
+            {
+                id: 8,
+                name: 'setDateTime',
+                headerSize: 2,
+                bytes: [Array],
+                parameters: [Object]
+            }
+        ],
+        bytes: [10,19,237,116,10,174,74,186,200,66,196,27,231,245,13,60,40,132],
+        lrc: {received: 119, calculated: 119}
+    } */
+}
 ```
-It's best to avoid using message.TYPE_AUTO due to performance penalty.
 
-Prepare command and get encoded data:
+Parse uplink message:
 
 ```js
-import SoftRestart from 'jooby-codec/analog/commands/downlink/SoftRestart.js';
-import SetTime2000 from 'jooby-codec/analog/commands/downlink/SetTime2000.js';
+import * as message from 'jooby-codec/mtx1/message/uplink';
+import * as frame from 'jooby-codec/mtx1/utils/frame.js';
+import getBytesFromHex from 'jooby-codec/utils/getBytesFromHex.js';
+
+const aesKey = [...Array(16).keys()];
+
+// a message with one getDeviceId command
+const messageBytes = getBytesFromHex('0d13cf5fa5a836724fc97a0735f817d49651');
+// the same message as a frame
+const frameBytes = getBytesFromHex('7e51fffffffe0d7d33cf5fa5a836724fc97a0735f817d4965178de7e');
+
+const parsedMessage = message.fromBytes(messageBytes, {aesKey});
+
+console.log('parsed message:', parsedMessage);
+/* output:
+{
+  messageId: 10,
+  accessLevel: 0,
+  commands: [
+    {
+      id: 5,
+      name: 'getDeviceId',
+      headerSize: 2,
+      bytes: [Array],
+      parameters: [Object]
+    }
+  ],
+  bytes: [
+     10,  16, 16,  5,  8,  0,
+     26, 121, 23, 20, 27, 29,
+    106,   0, 68
+  ],
+  lrc: { received: 68, calculated: 68 }
+} */
+
+const parsedFrame = frame.fromBytes(frameBytes);
+
+console.log('parsed frame:', parsedFrame);
+/* output:
+{
+  bytes: [
+    126, 81, 255, 255, 255, 254,  11,
+     16, 16,   5,   8,   0,  26, 121,
+     23, 20,  27,  29, 106,   0,  68,
+    151, 22, 126
+  ],
+  payload: [
+     11,  16, 16,  5,  8,  0,
+     26, 121, 23, 20, 27, 29,
+    106,   0, 68
+  ],
+  crc: { calculated: 5783, received: 5783 },
+  header: {
+    type: 81,
+    typeName: 'DATA_RESPONSE',
+    destination: 65535,
+    source: 65534
+  }
+} */
+
+// parsed successfully
+if ( 'bytes' in parsedFrame ) {
+    const parsedMessage2 = message.fromBytes(parsedFrame.payload, {aesKey});
+
+    if ( JSON.stringify(parsedMessage) === JSON.stringify(parsedMessage2) ) {
+        console.log('correct message');
+    } else {
+        throw new Error('parsedMessage and parsedMessage2 should be identical!');
+    }
+}
+```
 
-const command = new SetTime2000({sequenceNumber: 5, seconds: 9462957});
 
-// output command binary in hex representation
-// 02 05 05 00 90 64 ad
-console.log(command.toHex());
-// [2, 5, 5, 0, 144, 100, 173]
-console.log(command.toBytes());
+## Usage of OBIS Observer
+
+Add to the project:
+
+```js
+import {commands, message} from 'jooby-codec/obis-observer';
+
+// output all available downlink and uplink commands tree
+console.log(commands);
+// all uplink commands
+console.log(commands.uplink);
+// one particular command
+console.log(commands.uplink.getMeterId);
+
+// output main namespace for work with messages
+console.log(message);
 ```
 
-Combine a message from commands:
+But it's better to add only necessary commands to the project:
+
+```js
+// to get only downlink commands
+import {downlink} from 'jooby-codec/obis-observer/commands';
+// or slightly more efficient
+import * as downlink from 'jooby-codec/obis-observer/commands/downlink';
+
+// to get one particular command
+import * as getMeterInfo from 'jooby-codec/obis-observer/commands/downlink/getMeterInfo.js';
+```
+
+The last approach is preferred as it is more efficient and will init only a necessary commands.
+
+Prepare and parse downlink message:
 
 ```js
-const messageBytes = message.toBytes([
-    new SetTime2000({sequenceNumber: 78, seconds: 123456}),
-    new SoftRestart()
-]);
+import * as message from 'jooby-codec/obis-observer/message/downlink';
+import * as downlinkCommands from 'jooby-codec/obis-observer/commands/downlink';
+import getHexFromBytes from 'jooby-codec/utils/getHexFromBytes.js';
+
+const commands = [
+    {
+        id: downlinkCommands.getMeterProfile.id,
+        parameters: {requestId: 3, meterProfileId: 4}
+    }
+];
+const bytes = message.toBytes(commands);
+
+console.log('message encoded:', JSON.stringify(bytes));
+// output:
+[102,2,3,4]
+
+console.log('message encoded in HEX:', getHexFromBytes(bytes));
+// output:
+'66 02 03 04'
+
+// decode message back from bytes
+const parsedMessage = message.fromBytes(bytes);
+
+console.log('parsedMessage:', parsedMessage);
+// output:
+{
+    commands: [
+        {
+            id: 102,
+            name: 'getMeterProfile',
+            headerSize: 2,
+            bytes: [Array],
+            parameters: [Object]
+        }
+    ],
+    bytes: [102, 2, 3, 4]
+}
 ```
 
-or to get in a hex format:
+Parse uplink message:
 
 ```js
-import DayMC from 'jooby-codec/analog/commands/uplink/DayMC.js';
-import LastEvent from 'jooby-codec/analog/commands/uplink/LastEvent.js';
+import * as message from 'jooby-codec/obis-observer/message/uplink';
+
+// binary data received from a device
+const bytes = [0x10, 0x0d, 0x02, 0x00, 0x00, 0x00, 0x51, 0x2c, 0x2d, 0xea, 0xae, 0x2c, 0x2f, 0x0a, 0xf6];
 
-const commandInstancesArray = [
-    new LastEvent(
+// decode it
+const payload = message.fromBytes(bytes);
+
+if ( 'error' in payload ) {
+    console.log('decode failure:', payload.error, payload.message);
+} else {
+    console.log('message decoded:', payload.commands);
+    // output:
+    [
         {
-            sequenceNumber: 32,
-            status: {
-                isBatteryLow: true,
-                isButtonReleased: false,
-                isConnectionLost: true,
-                isMagneticInfluence: false
+            id: 16,
+            name: 'getArchiveState',
+            headerSize: 2,
+            bytes: [
+                16, 13, 2, 0, 0, 0, 81, 44, 45, 234, 174, 44, 47, 10, 246
+            ],
+            parameters: {
+                requestId: 2,
+                archiveRecordsNumber: 81,
+                eldestTime2000: 741206702,
+                newestTime2000: 741280502
             }
-        },
-        hardwareTypes.GASI3
-    ),
-    new DayMC({
-        startTime2000: 756604800,
-        channelList: [
-            {value: 131, index: 3},
-            {value: 8, index: 5},
-            {value: 10, index: 7},
-            {value: 12, index: 1}
-        ]
-    })
-];
-
-const messageBytes = message.toHex(commandInstancesArray, {prefix: '0x'});
-// 0x62 0x20 0x09 0x16 0x09 0x2f 0x97 0xaa 0x01 0x0c 0x83 0x01 0x08 0x0a 0x9e
+        }
+    ]
+}
 ```

package/dist/Command.d.ts

@@ -1,32 +0,0 @@
-import { IHexFormatOptions } from './config.js';
-import { IBytesConversionFormatOptions } from './utils/bytesConversion.js';
-export interface ICommandExample {
-    name: string;
-    parameters?: object;
-    config?: {
-        hardwareType?: number;
-    };
-    hex: {
-        header: string;
-        body: string;
-    };
-}
-export type TCommandExampleList = Array<ICommandExample>;
-export type TJsonOptions = IBytesConversionFormatOptions;
-export declare const defaultJsonOptions: IBytesConversionFormatOptions;
-declare abstract class Command {
-    static id: number;
-    static directionType: unknown;
-    static title: string;
-    static examples: TCommandExampleList;
-    static hasParameters: boolean;
-    parameters: unknown;
-    size: number;
-    static getId(): string;
-    getParameters(): unknown;
-    toBytes(): Uint8Array;
-    toHex(options?: IHexFormatOptions): string;
-    toBase64(): string;
-    toJson(): string;
-}
-export default Command;

package/dist/Command.js

@@ -1,31 +0,0 @@
-import getHexFromBytes from './utils/getHexFromBytes.js';
-import getHexFromNumber from './utils/getHexFromNumber.js';
-import getBase64FromBytes from './utils/getBase64FromBytes.js';
-import { defaultFormatOptions } from './utils/bytesConversion.js';
-export const defaultJsonOptions = defaultFormatOptions;
-class Command {
-    constructor() {
-        this.size = 0;
-    }
-    static getId() {
-        return getHexFromNumber(this.id);
-    }
-    getParameters() {
-        return this.parameters;
-    }
-    toBytes() {
-        throw new Error('not implemented!');
-    }
-    toHex(options = {}) {
-        return getHexFromBytes(this.toBytes(), options);
-    }
-    toBase64() {
-        return getBase64FromBytes(this.toBytes());
-    }
-    toJson() {
-        return JSON.stringify(this.getParameters());
-    }
-}
-Command.hasParameters = false;
-export default Command;
-//# sourceMappingURL=Command.js.map

package/dist/Command.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"Command.js","sourceRoot":"","sources":["../src/Command.ts"],"names":[],"mappings":"AACA,OAAO,eAAe,MAAM,4BAA4B,CAAC;AACzD,OAAO,gBAAgB,MAAM,6BAA6B,CAAC;AAC3D,OAAO,kBAAkB,MAAM,+BAA+B,CAAC;AAC/D,OAAO,EAAgC,oBAAoB,EAAC,MAAM,4BAA4B,CAAC;AAmB/F,MAAM,CAAC,MAAM,kBAAkB,GAAG,oBAAoB,CAAC;AAMvD,MAAe,OAAO;IAAtB;QAeI,SAAI,GAAW,CAAC,CAAC;IAkCrB,CAAC;IA9BG,MAAM,CAAC,KAAK;QACR,OAAO,gBAAgB,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;IACrC,CAAC;IAGD,aAAa;QACT,OAAO,IAAI,CAAC,UAAU,CAAC;IAC3B,CAAC;IAGD,OAAO;QACH,MAAM,IAAI,KAAK,CAAC,kBAAkB,CAAC,CAAC;IACxC,CAAC;IAED,KAAK,CAAG,UAA6B,EAAE;QACnC,OAAO,eAAe,CAAC,IAAI,CAAC,OAAO,EAAE,EAAE,OAAO,CAAC,CAAC;IACpD,CAAC;IAED,QAAQ;QACJ,OAAO,kBAAkB,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC,CAAC;IAC9C,CAAC;IAOD,MAAM;QACF,OAAO,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,aAAa,EAAE,CAAC,CAAC;IAChD,CAAC;;AAvCM,qBAAa,GAAG,KAAK,AAAR,CAAS;AA2CjC,eAAe,OAAO,CAAC"}

package/dist/analog/Command.d.ts

@@ -1,14 +0,0 @@
-import BaseCommand from '../Command.js';
-export { ICommandExample, TCommandExampleList, TJsonOptions, defaultJsonOptions } from '../Command.js';
-export interface ICommandBinary {
-    header: Uint8Array;
-    body?: Uint8Array;
-    bytes: Uint8Array;
-}
-declare abstract class Command extends BaseCommand {
-    config: unknown;
-    static toBinary(id: number, commandData?: Uint8Array): ICommandBinary;
-    toBinary(): ICommandBinary;
-    toBytes(): Uint8Array;
-}
-export default Command;

package/dist/analog/Command.js

@@ -1,28 +0,0 @@
-import * as header from './header.js';
-import BaseCommand from '../Command.js';
-export { defaultJsonOptions } from '../Command.js';
-class Command extends BaseCommand {
-    static toBinary(id, commandData) {
-        const commandLength = commandData?.length ?? 0;
-        const headerData = header.toBytes(id, commandLength);
-        if (commandData && commandLength) {
-            return {
-                header: headerData,
-                body: commandData,
-                bytes: new Uint8Array([...headerData, ...commandData])
-            };
-        }
-        return {
-            header: headerData,
-            bytes: headerData
-        };
-    }
-    toBinary() {
-        throw new Error('not implemented!');
-    }
-    toBytes() {
-        return this.toBinary().bytes;
-    }
-}
-export default Command;
-//# sourceMappingURL=Command.js.map

package/dist/analog/Command.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"Command.js","sourceRoot":"","sources":["../../src/analog/Command.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,aAAa,CAAC;AACtC,OAAO,WAAW,MAAM,eAAe,CAAC;AAGxC,OAAO,EAAqD,kBAAkB,EAAC,MAAM,eAAe,CAAC;AAYrG,MAAe,OAAQ,SAAQ,WAAW;IAWtC,MAAM,CAAC,QAAQ,CAAG,EAAU,EAAE,WAAwB;QAClD,MAAM,aAAa,GAAG,WAAW,EAAE,MAAM,IAAI,CAAC,CAAC;QAC/C,MAAM,UAAU,GAAG,MAAM,CAAC,OAAO,CAAC,EAAE,EAAE,aAAa,CAAC,CAAC;QAErD,IAAK,WAAW,IAAI,aAAa,EAAG,CAAC;YACjC,OAAO;gBACH,MAAM,EAAE,UAAU;gBAClB,IAAI,EAAE,WAAW;gBACjB,KAAK,EAAE,IAAI,UAAU,CAAC,CAAC,GAAG,UAAU,EAAE,GAAG,WAAW,CAAC,CAAC;aACzD,CAAC;QACN,CAAC;QAGD,OAAO;YACH,MAAM,EAAE,UAAU;YAClB,KAAK,EAAE,UAAU;SACpB,CAAC;IACN,CAAC;IAGD,QAAQ;QACJ,MAAM,IAAI,KAAK,CAAC,kBAAkB,CAAC,CAAC;IACxC,CAAC;IAGD,OAAO;QACH,OAAO,IAAI,CAAC,QAAQ,EAAE,CAAC,KAAK,CAAC;IACjC,CAAC;CACJ;AAGD,eAAe,OAAO,CAAC"}