matterbridge-roborock-vacuum-plugin-regions 1.1.1-jb.1

package/dist/roborockCommunication/broadcast/listener/implementation/syncMessageListener.js

@@ -0,0 +1,33 @@
+import { debugStringify } from 'matterbridge/logger';
+import { Protocol } from '../../model/protocol.js';
+export class SyncMessageListener {
+    pending = new Map();
+    logger;
+    constructor(logger) {
+        this.logger = logger;
+    }
+    waitFor(messageId, request, resolve, reject) {
+        this.pending.set(messageId, resolve);
+        setTimeout(() => {
+            this.pending.delete(messageId);
+            reject(new Error(`Message timeout for messageId: ${messageId}, request: ${debugStringify(request)}`));
+        }, 10000);
+    }
+    async onMessage(message) {
+        if (message.contain(Protocol.rpc_response)) {
+            const dps = message.get(Protocol.rpc_response);
+            const messageId = dps.id;
+            const responseHandler = this.pending.get(messageId);
+            if (responseHandler) {
+                responseHandler(dps.result);
+            }
+            this.pending.delete(messageId);
+            return;
+        }
+        if (message.contain(Protocol.map_response)) {
+            const dps = message.get(Protocol.map_response);
+            this.pending.delete(dps.id);
+            return;
+        }
+    }
+}

package/dist/roborockCommunication/broadcast/listener/index.js

@@ -0,0 +1 @@
+export { SimpleMessageListener } from './implementation/simpleMessageListener.js';

package/dist/roborockCommunication/broadcast/messageProcessor.js

@@ -0,0 +1,148 @@
+import { debugStringify } from 'matterbridge/logger';
+import { SimpleMessageListener } from './listener/index.js';
+import { RequestMessage } from './model/requestMessage.js';
+import { DeviceStatus } from '../Zmodel/deviceStatus.js';
+export class MessageProcessor {
+    client;
+    messageListener;
+    logger;
+    constructor(client) {
+        this.client = client;
+        this.messageListener = new SimpleMessageListener();
+        this.client.registerMessageListener(this.messageListener);
+    }
+    injectLogger(logger) {
+        this.logger = logger;
+    }
+    registerListener(listener) {
+        this.messageListener.registerListener(listener);
+    }
+    async getNetworkInfo(duid) {
+        const request = new RequestMessage({ method: 'get_network_info' });
+        return await this.client.get(duid, request);
+    }
+    async getDeviceStatus(duid) {
+        const request = new RequestMessage({ method: 'get_status' });
+        const response = await this.client.get(duid, request);
+        if (response) {
+            this.logger?.debug('Device status: ', debugStringify(response));
+            return new DeviceStatus(response);
+        }
+        return undefined;
+    }
+    async getDeviceStatusOverMQTT(duid) {
+        const request = new RequestMessage({ method: 'get_status', secure: true });
+        const response = await this.client.get(duid, request);
+        if (response) {
+            this.logger?.debug('MQTT - Device status: ', debugStringify(response));
+            return new DeviceStatus(response);
+        }
+        return undefined;
+    }
+    async getRooms(duid) {
+        const request = new RequestMessage({ method: 'get_room_mapping' });
+        return this.client.get(duid, request);
+    }
+    async gotoDock(duid) {
+        const request = new RequestMessage({ method: 'app_charge' });
+        return this.client.send(duid, request);
+    }
+    async startClean(duid) {
+        const request = new RequestMessage({ method: 'app_start' });
+        return this.client.send(duid, request);
+    }
+    async startRoomClean(duid, roomIds, repeat) {
+        const request = new RequestMessage({
+            method: 'app_segment_clean',
+            params: [{ segments: roomIds, repeat: repeat }],
+        });
+        return this.client.send(duid, request);
+    }
+    async pauseClean(duid) {
+        const request = new RequestMessage({ method: 'app_pause' });
+        return this.client.send(duid, request);
+    }
+    async resumeClean(duid) {
+        const request = new RequestMessage({ method: 'app_resume' });
+        return this.client.send(duid, request);
+    }
+    async stopClean(duid) {
+        const request = new RequestMessage({ method: 'app_stop' });
+        return this.client.send(duid, request);
+    }
+    async sendCustomMessage(duid, def) {
+        const request = new RequestMessage(def);
+        return this.client.send(duid, request);
+    }
+    getCustomMessage(duid, def) {
+        return this.client.get(duid, def);
+    }
+    async findMyRobot(duid) {
+        const request = new RequestMessage({ method: 'find_me' });
+        return this.client.get(duid, request);
+    }
+    async getCleanModeData(duid) {
+        const currentMopMode = await this.getCustomMessage(duid, new RequestMessage({ method: 'get_mop_mode' }));
+        const suctionPowerRaw = await this.getCustomMessage(duid, new RequestMessage({ method: 'get_custom_mode' }));
+        const waterFlowRaw = await this.getCustomMessage(duid, new RequestMessage({ method: 'get_water_box_custom_mode' }));
+        let suctionPower;
+        let waterFlow;
+        let mopRoute;
+        let distance_off = 0;
+        if (Array.isArray(suctionPowerRaw)) {
+            suctionPower = suctionPowerRaw[0];
+        }
+        else {
+            suctionPower = suctionPowerRaw;
+        }
+        if (Array.isArray(currentMopMode)) {
+            mopRoute = currentMopMode[0];
+        }
+        else {
+            mopRoute = currentMopMode;
+        }
+        if (typeof waterFlowRaw === 'object' && waterFlowRaw !== null && 'water_box_mode' in waterFlowRaw) {
+            waterFlow = waterFlowRaw.water_box_mode;
+            if ('distance_off' in waterFlowRaw) {
+                distance_off = waterFlowRaw.distance_off ?? 0;
+            }
+        }
+        else {
+            waterFlow = waterFlowRaw;
+        }
+        return {
+            suctionPower: suctionPower,
+            waterFlow: waterFlow,
+            distance_off: distance_off,
+            mopRoute: mopRoute,
+        };
+    }
+    async changeCleanMode(duid, suctionPower, waterFlow, mopRoute, distance_off) {
+        this.logger?.notice(`Change clean mode for ${duid} to suctionPower: ${suctionPower}, waterFlow: ${waterFlow}, mopRoute: ${mopRoute}, distance_off: ${distance_off}`);
+        const currentMopMode = await this.getCustomMessage(duid, new RequestMessage({ method: 'get_custom_mode' }));
+        const smartMopMode = 110;
+        const smartMopRoute = 306;
+        const customMopMode = 106;
+        const customMopRoute = 302;
+        if (currentMopMode == smartMopMode && mopRoute == smartMopRoute)
+            return;
+        if (currentMopMode == customMopMode && mopRoute == customMopRoute)
+            return;
+        if (currentMopMode == smartMopMode) {
+            await this.client.send(duid, new RequestMessage({ method: 'set_mop_mode', params: [customMopRoute] }));
+        }
+        if (suctionPower && suctionPower != 0) {
+            await this.client.send(duid, new RequestMessage({ method: 'set_custom_mode', params: [suctionPower] }));
+        }
+        const CustomizeWithDistanceOff = 207;
+        if (waterFlow && waterFlow == CustomizeWithDistanceOff && distance_off && distance_off != 0) {
+            await this.client.send(duid, new RequestMessage({ method: 'set_water_box_custom_mode', params: { 'water_box_mode': waterFlow, 'distance_off': distance_off } }));
+        }
+        else if (waterFlow && waterFlow != 0) {
+            await this.client.send(duid, new RequestMessage({ method: 'set_water_box_custom_mode', params: [waterFlow] }));
+        }
+        if (mopRoute && mopRoute != 0) {
+            await this.client.send(duid, new RequestMessage({ method: 'set_mop_mode', params: [mopRoute] }));
+        }
+    }
+}

package/dist/roborockCommunication/broadcast/model/contentMessage.js

@@ -0,0 +1 @@
+export {};

package/dist/roborockCommunication/broadcast/model/dps.js

@@ -0,0 +1 @@
+export {};

package/dist/roborockCommunication/broadcast/model/headerMessage.js

@@ -0,0 +1 @@
+export {};

package/dist/roborockCommunication/broadcast/model/messageContext.js

@@ -0,0 +1,37 @@
+import { randomBytes, randomInt } from 'node:crypto';
+import * as CryptoUtils from '../../helper/cryptoHelper.js';
+export class MessageContext {
+    endpoint;
+    devices = new Map();
+    nonce;
+    serializeNonce;
+    constructor(userdata) {
+        this.endpoint = CryptoUtils.md5bin(userdata.rriot.k).subarray(8, 14).toString('base64');
+        this.nonce = randomInt(1000, 1000000);
+        this.serializeNonce = randomBytes(16);
+    }
+    registerDevice(duid, localKey, pv, nonce) {
+        this.devices.set(duid, { localKey: localKey, protocolVersion: pv, nonce });
+    }
+    updateNonce(duid, nonce) {
+        const device = this.devices.get(duid);
+        if (device) {
+            device.nonce = nonce;
+        }
+    }
+    getSerializeNonceAsHex() {
+        return this.serializeNonce.toString('hex').toUpperCase();
+    }
+    getLocalKey(duid) {
+        return this.devices.get(duid)?.localKey;
+    }
+    getProtocolVersion(duid) {
+        return this.devices.get(duid)?.protocolVersion;
+    }
+    getDeviceNonce(duid) {
+        return this.devices.get(duid)?.nonce;
+    }
+    getEndpoint() {
+        return this.endpoint;
+    }
+}

package/dist/roborockCommunication/broadcast/model/protocol.js

@@ -0,0 +1,28 @@
+export var Protocol;
+(function (Protocol) {
+    Protocol[Protocol["hello_request"] = 0] = "hello_request";
+    Protocol[Protocol["hello_response"] = 1] = "hello_response";
+    Protocol[Protocol["ping_request"] = 2] = "ping_request";
+    Protocol[Protocol["ping_response"] = 3] = "ping_response";
+    Protocol[Protocol["general_request"] = 4] = "general_request";
+    Protocol[Protocol["general_response"] = 5] = "general_response";
+    Protocol[Protocol["rpc_request"] = 101] = "rpc_request";
+    Protocol[Protocol["rpc_response"] = 102] = "rpc_response";
+    Protocol[Protocol["error"] = 120] = "error";
+    Protocol[Protocol["status_update"] = 121] = "status_update";
+    Protocol[Protocol["battery"] = 122] = "battery";
+    Protocol[Protocol["suction_power"] = 123] = "suction_power";
+    Protocol[Protocol["water_box_mode"] = 124] = "water_box_mode";
+    Protocol[Protocol["main_brush_work_time"] = 125] = "main_brush_work_time";
+    Protocol[Protocol["side_brush_work_time"] = 126] = "side_brush_work_time";
+    Protocol[Protocol["filter_work_time"] = 127] = "filter_work_time";
+    Protocol[Protocol["additional_props"] = 128] = "additional_props";
+    Protocol[Protocol["task_complete"] = 130] = "task_complete";
+    Protocol[Protocol["task_cancel_low_power"] = 131] = "task_cancel_low_power";
+    Protocol[Protocol["task_cancel_in_motion"] = 132] = "task_cancel_in_motion";
+    Protocol[Protocol["charge_status"] = 133] = "charge_status";
+    Protocol[Protocol["drying_status"] = 134] = "drying_status";
+    Protocol[Protocol["back_type"] = 139] = "back_type";
+    Protocol[Protocol["map_response"] = 301] = "map_response";
+    Protocol[Protocol["some_thing_happened_when_socket_closed"] = 500] = "some_thing_happened_when_socket_closed";
+})(Protocol || (Protocol = {}));

package/dist/roborockCommunication/broadcast/model/requestMessage.js

@@ -0,0 +1,38 @@
+import { Protocol } from './protocol.js';
+import { randomInt } from 'node:crypto';
+export class RequestMessage {
+    messageId;
+    protocol;
+    method;
+    params;
+    secure;
+    timestamp;
+    nonce;
+    constructor(args) {
+        this.messageId = args.messageId ?? randomInt(10000, 32767);
+        this.protocol = args.protocol ?? Protocol.rpc_request;
+        this.method = args.method;
+        this.params = args.params;
+        this.secure = args.secure ?? false;
+        this.nonce = args.nonce ?? randomInt(10000, 32767);
+        this.timestamp = args.timestamp ?? Math.floor(Date.now() / 1000);
+    }
+    toMqttRequest() {
+        return this;
+    }
+    toLocalRequest() {
+        if (this.protocol == Protocol.rpc_request) {
+            return new RequestMessage({
+                messageId: this.messageId,
+                protocol: Protocol.general_request,
+                method: this.method,
+                params: this.params,
+                secure: this.secure,
+                timestamp: this.timestamp,
+            });
+        }
+        else {
+            return this;
+        }
+    }
+}

package/dist/roborockCommunication/broadcast/model/responseMessage.js

@@ -0,0 +1,14 @@
+export class ResponseMessage {
+    duid;
+    dps;
+    constructor(duid, dps) {
+        this.duid = duid;
+        this.dps = dps;
+    }
+    contain(index) {
+        return this.dps[index.toString()] !== undefined;
+    }
+    get(index) {
+        return this.dps[index.toString()];
+    }
+}

package/dist/roborockCommunication/helper/chunkBuffer.js

@@ -0,0 +1,17 @@
+export class ChunkBuffer {
+    buffer = Buffer.alloc(0);
+    get() {
+        return this.buffer;
+    }
+    reset() {
+        this.buffer = Buffer.alloc(0);
+    }
+    append(message) {
+        if (this.buffer.length == 0) {
+            this.buffer = message;
+        }
+        else {
+            this.buffer = Buffer.concat([this.buffer, message]);
+        }
+    }
+}

package/dist/roborockCommunication/helper/cryptoHelper.js

@@ -0,0 +1,23 @@
+import crypto from 'node:crypto';
+export function md5bin(str) {
+    return crypto.createHash('md5').update(str).digest();
+}
+export function md5hex(str) {
+    return crypto.createHash('md5').update(str).digest('hex');
+}
+export function decryptECB(encrypted, aesKey) {
+    const decipher = crypto.createDecipheriv('aes-128-ecb', aesKey, null);
+    decipher.setAutoPadding(false);
+    let decrypted = decipher.update(encrypted, 'binary', 'utf8');
+    decrypted += decipher.final('utf8');
+    return removePadding(decrypted);
+}
+function removePadding(str) {
+    const paddingLength = str.charCodeAt(str.length - 1);
+    return str.slice(0, -paddingLength);
+}
+export const SALT = 'TXdfu$jyZ#TZHsg4';
+export function encodeTimestamp(timestamp) {
+    const hex = timestamp.toString(16).padStart(8, '0').split('');
+    return [5, 6, 3, 7, 1, 2, 0, 4].map((idx) => hex[idx]).join('');
+}

package/dist/roborockCommunication/helper/messageDeserializer.js

@@ -0,0 +1,98 @@
+import crypto from 'node:crypto';
+import CRC32 from 'crc-32';
+import { ResponseMessage } from '../broadcast/model/responseMessage.js';
+import * as CryptoUtils from './cryptoHelper.js';
+import { Protocol } from '../broadcast/model/protocol.js';
+import { Parser } from 'binary-parser/dist/binary_parser.js';
+export class MessageDeserializer {
+    context;
+    headerMessageParser;
+    contentMessageParser;
+    logger;
+    supportedVersions = ['1.0', 'A01', 'B01'];
+    constructor(context, logger) {
+        this.context = context;
+        this.logger = logger;
+        this.headerMessageParser = new Parser()
+            .endianness('big')
+            .string('version', {
+            length: 3,
+        })
+            .uint32('seq')
+            .uint32('nonce')
+            .uint32('timestamp')
+            .uint16('protocol');
+        this.contentMessageParser = new Parser()
+            .endianness('big')
+            .uint16('payloadLen')
+            .buffer('payload', {
+            length: 'payloadLen',
+        })
+            .uint32('crc32');
+    }
+    deserialize(duid, message) {
+        const header = this.headerMessageParser.parse(message);
+        if (!this.supportedVersions.includes(header.version)) {
+            throw new Error('unknown protocol version ' + header.version);
+        }
+        if (header.protocol === Protocol.hello_response || header.protocol === Protocol.ping_response) {
+            const dpsValue = {
+                id: header.seq,
+                result: {
+                    version: header.version,
+                    nonce: header.nonce,
+                },
+            };
+            return new ResponseMessage(duid, { [header.protocol.toString()]: dpsValue });
+        }
+        const data = this.contentMessageParser.parse(message.subarray(this.headerMessageParser.sizeOf()));
+        const crc32 = CRC32.buf(message.subarray(0, message.length - 4)) >>> 0;
+        const expectedCrc32 = message.readUInt32BE(message.length - 4);
+        if (crc32 != expectedCrc32) {
+            throw new Error(`Wrong CRC32 ${crc32}, expected ${expectedCrc32}`);
+        }
+        const localKey = this.context.getLocalKey(duid);
+        if (!localKey) {
+            this.logger.notice(`Unable to retrieve local key for ${duid}, it should be from other vacuums`);
+            return new ResponseMessage(duid, { dps: { id: 0, result: null } });
+        }
+        if (header.version == '1.0') {
+            const aesKey = CryptoUtils.md5bin(CryptoUtils.encodeTimestamp(header.timestamp) + localKey + CryptoUtils.SALT);
+            const decipher = crypto.createDecipheriv('aes-128-ecb', aesKey, null);
+            data.payload = Buffer.concat([decipher.update(data.payload), decipher.final()]);
+        }
+        else if (header.version == 'A01') {
+            const iv = CryptoUtils.md5hex(header.nonce.toString(16).padStart(8, '0') + '726f626f726f636b2d67a6d6da').substring(8, 24);
+            const decipher = crypto.createDecipheriv('aes-128-cbc', localKey, iv);
+            data.payload = Buffer.concat([decipher.update(data.payload), decipher.final()]);
+        }
+        else if (header.version == 'B01') {
+            const iv = CryptoUtils.md5hex(header.nonce.toString(16).padStart(8, '0') + '5wwh9ikChRjASpMU8cxg7o1d2E').substring(9, 25);
+            const decipher = crypto.createDecipheriv('aes-128-cbc', localKey, iv);
+            data.payload = Buffer.concat([decipher.update(data.payload), decipher.final()]);
+        }
+        if (header.protocol == Protocol.map_response) {
+            return new ResponseMessage(duid, { dps: { id: 0, result: null } });
+        }
+        if (header.protocol == Protocol.rpc_response || header.protocol == Protocol.general_request) {
+            return this.deserializeRpcResponse(duid, data);
+        }
+        else {
+            this.logger.error('unknown protocol: ' + header.protocol);
+            return new ResponseMessage(duid, { dps: { id: 0, result: null } });
+        }
+    }
+    deserializeRpcResponse(duid, data) {
+        const payload = JSON.parse(data.payload.toString());
+        const dps = payload.dps;
+        this.parseJsonInDps(dps, Protocol.general_request);
+        this.parseJsonInDps(dps, Protocol.rpc_response);
+        return new ResponseMessage(duid, dps);
+    }
+    parseJsonInDps(dps, index) {
+        const indexString = index.toString();
+        if (dps[indexString] !== undefined) {
+            dps[indexString] = JSON.parse(dps[indexString]);
+        }
+    }
+}

package/dist/roborockCommunication/helper/messageSerializer.js

@@ -0,0 +1,84 @@
+import * as CryptoUtils from './cryptoHelper.js';
+import crypto from 'node:crypto';
+import CRC32 from 'crc-32';
+import { Protocol } from '../broadcast/model/protocol.js';
+export class MessageSerializer {
+    context;
+    logger;
+    sequence = 1;
+    supportedVersions = ['1.0', 'A01', 'B01'];
+    constructor(context, logger) {
+        this.context = context;
+        this.logger = logger;
+    }
+    serialize(duid, request) {
+        const messageId = request.messageId;
+        const buffer = this.buildBuffer(duid, messageId, request);
+        return { messageId: messageId, buffer: buffer };
+    }
+    buildPayload(messageId, request) {
+        const data = {
+            id: messageId,
+            method: request.method ?? '',
+            params: request.params,
+            security: undefined,
+            result: undefined,
+        };
+        if (request.secure) {
+            data.security = {
+                endpoint: this.context.getEndpoint(),
+                nonce: this.context.getSerializeNonceAsHex(),
+            };
+        }
+        return {
+            dps: {
+                [request.protocol]: JSON.stringify(data),
+            },
+            t: request.timestamp,
+        };
+    }
+    buildBuffer(duid, messageId, request) {
+        const version = this.context.getProtocolVersion(duid);
+        if (!version || !this.supportedVersions.includes(version)) {
+            throw new Error('unknown protocol version ' + version);
+        }
+        let encrypted;
+        if (request.protocol === Protocol.hello_response || request.protocol === Protocol.ping_response) {
+            encrypted = Buffer.alloc(0);
+        }
+        const localKey = this.context.getLocalKey(duid);
+        const payloadData = this.buildPayload(messageId, request);
+        const payload = JSON.stringify(payloadData);
+        if (version == '1.0') {
+            const aesKey = CryptoUtils.md5bin(CryptoUtils.encodeTimestamp(payloadData.t) + localKey + CryptoUtils.SALT);
+            const cipher = crypto.createCipheriv('aes-128-ecb', aesKey, null);
+            encrypted = Buffer.concat([cipher.update(payload), cipher.final()]);
+        }
+        else if (version == 'A01') {
+            const encoder = new TextEncoder();
+            const iv = CryptoUtils.md5hex(request.nonce.toString(16).padStart(8, '0') + '726f626f726f636b2d67a6d6da').substring(8, 24);
+            const cipher = crypto.createCipheriv('aes-128-cbc', encoder.encode(localKey), iv);
+            encrypted = Buffer.concat([cipher.update(payload), cipher.final()]);
+        }
+        else if (version == 'B01') {
+            const encoder = new TextEncoder();
+            const iv = CryptoUtils.md5hex(request.nonce.toString(16).padStart(8, '0') + '5wwh9ikChRjASpMU8cxg7o1d2E').substring(9, 25);
+            const cipher = crypto.createCipheriv('aes-128-cbc', encoder.encode(localKey), iv);
+            encrypted = Buffer.concat([cipher.update(payload), cipher.final()]);
+        }
+        else {
+            throw new Error('unable to build the message: unsupported protocol version: ' + version);
+        }
+        const msg = Buffer.alloc(23 + encrypted.length);
+        msg.write(version);
+        msg.writeUint32BE(this.sequence++ & 0xffffffff, 3);
+        msg.writeUint32BE(request.nonce & 0xffffffff, 7);
+        msg.writeUint32BE(request.timestamp, 11);
+        msg.writeUint16BE(request.protocol, 15);
+        msg.writeUint16BE(encrypted.length, 17);
+        encrypted.copy(msg, 19);
+        const crc32 = CRC32.buf(msg.subarray(0, msg.length - 4)) >>> 0;
+        msg.writeUint32BE(crc32, msg.length - 4);
+        return msg;
+    }
+}

package/dist/roborockCommunication/helper/nameDecoder.js

@@ -0,0 +1,66 @@
+const token = '%[a-f0-9]{2}';
+const singleMatcher = new RegExp('(' + token + ')|([^%]+?)', 'gi');
+const multiMatcher = new RegExp('(' + token + ')+', 'gi');
+function decodeComponents(components, split = undefined) {
+    try {
+        return [decodeURIComponent(components.join(''))];
+    }
+    catch {
+    }
+    if (components.length === 1) {
+        return components;
+    }
+    split = split || 1;
+    const left = components.slice(0, split);
+    const right = components.slice(split);
+    return Array.prototype.concat.call([], decodeComponents(left), decodeComponents(right));
+}
+function decode(input) {
+    try {
+        return decodeURIComponent(input);
+    }
+    catch {
+        let tokens = input.match(singleMatcher) || [];
+        for (let i = 1; i < tokens.length; i++) {
+            input = decodeComponents(tokens, i).join('');
+            tokens = input.match(singleMatcher) || [];
+        }
+        return input;
+    }
+}
+function customDecodeURIComponent(input) {
+    const replaceMap = {
+        '%FE%FF': '\uFFFD\uFFFD',
+        '%FF%FE': '\uFFFD\uFFFD',
+    };
+    let match = multiMatcher.exec(input);
+    while (match) {
+        try {
+            replaceMap[match[0]] = decodeURIComponent(match[0]);
+        }
+        catch {
+            const result = decode(match[0]);
+            if (result !== match[0]) {
+                replaceMap[match[0]] = result;
+            }
+        }
+        match = multiMatcher.exec(input);
+    }
+    replaceMap['%C2'] = '\uFFFD';
+    const entries = Object.keys(replaceMap);
+    for (const key of entries) {
+        input = input.replace(new RegExp(key, 'g'), replaceMap[key]);
+    }
+    return input;
+}
+export default function decodeComponent(encodedURI) {
+    if (encodedURI === undefined) {
+        return undefined;
+    }
+    try {
+        return decodeURIComponent(encodedURI);
+    }
+    catch {
+        return customDecodeURIComponent(encodedURI);
+    }
+}

package/dist/roborockCommunication/helper/sequence.js

@@ -0,0 +1,16 @@
+export class Sequence {
+    min;
+    max;
+    current;
+    constructor(min, max) {
+        this.min = min;
+        this.max = max;
+        this.current = min;
+    }
+    next() {
+        if (this.current > this.max) {
+            this.current = this.min;
+        }
+        return this.current++;
+    }
+}

package/dist/roborockCommunication/index.js

@@ -0,0 +1,13 @@
+export { RoborockAuthenticateApi } from './RESTAPI/roborockAuthenticateApi.js';
+export { RoborockIoTApi } from './RESTAPI/roborockIoTApi.js';
+export { MessageProcessor } from './broadcast/messageProcessor.js';
+export { VacuumErrorCode } from './Zenum/vacuumAndDockErrorCode.js';
+export { RequestMessage } from './broadcast/model/requestMessage.js';
+export { Protocol } from './broadcast/model/protocol.js';
+export { ClientRouter } from './broadcast/clientRouter.js';
+export { DeviceStatus } from './Zmodel/deviceStatus.js';
+export { ResponseMessage } from './broadcast/model/responseMessage.js';
+export { MapInfo } from './Zmodel/mapInfo.js';
+export { AdditionalPropCode } from './Zenum/additionalPropCode.js';
+export { AuthenticateResponseCode } from './Zenum/authenticateResponseCode.js';
+export { Scene } from './Zmodel/scene.js';