njs-modbus 1.3.1 → 1.3.2

package/dist/index.mjs

@@ -1,2108 +0,0 @@
-import EventEmitter from 'node:events';
-import { SerialPort } from 'serialport';
-import { Socket, createServer } from 'node:net';
-import { createSocket } from 'node:dgram';
-
-var ErrorCode;
-(function (ErrorCode) {
-    ErrorCode[ErrorCode["ILLEGAL_FUNCTION"] = 1] = "ILLEGAL_FUNCTION";
-    ErrorCode[ErrorCode["ILLEGAL_DATA_ADDRESS"] = 2] = "ILLEGAL_DATA_ADDRESS";
-    ErrorCode[ErrorCode["ILLEGAL_DATA_VALUE"] = 3] = "ILLEGAL_DATA_VALUE";
-    ErrorCode[ErrorCode["SERVER_DEVICE_FAILURE"] = 4] = "SERVER_DEVICE_FAILURE";
-    ErrorCode[ErrorCode["ACKNOWLEDGE"] = 5] = "ACKNOWLEDGE";
-    ErrorCode[ErrorCode["SERVER_DEVICE_BUSY"] = 6] = "SERVER_DEVICE_BUSY";
-    ErrorCode[ErrorCode["MEMORY_PARITY_ERROR"] = 8] = "MEMORY_PARITY_ERROR";
-    ErrorCode[ErrorCode["GATEWAY_PATH_UNAVAILABLE"] = 10] = "GATEWAY_PATH_UNAVAILABLE";
-    ErrorCode[ErrorCode["GATEWAY_TARGET_DEVICE_FAILED_TO_RESPOND"] = 11] = "GATEWAY_TARGET_DEVICE_FAILED_TO_RESPOND";
-})(ErrorCode || (ErrorCode = {}));
-const PREFIX = 'MODBUS_ERROR_CODE_';
-function getErrorByCode(code) {
-    return new Error(PREFIX + code);
-}
-function getCodeByError(err) {
-    if (err.message.startsWith(PREFIX)) {
-        return Number(err.message.slice(PREFIX.length));
-    }
-    return ErrorCode.SERVER_DEVICE_FAILURE;
-}
-
-class AbstractPhysicalLayer extends EventEmitter {
-}
-
-class SerialPhysicalLayer extends AbstractPhysicalLayer {
-    get isOpen() {
-        return this._serialport.isOpen;
-    }
-    get destroyed() {
-        return this._destroyed;
-    }
-    get baudRate() {
-        return this._baudRate;
-    }
-    constructor(options) {
-        super();
-        Object.defineProperty(this, "TYPE", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: 'SERIAL'
-        });
-        Object.defineProperty(this, "_serialport", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "_destroyed", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: false
-        });
-        Object.defineProperty(this, "_baudRate", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this._serialport = new SerialPort(Object.assign(Object.assign({}, options), { autoOpen: false }));
-        this._baudRate = options.baudRate;
-    }
-    open() {
-        if (this.destroyed) {
-            return Promise.reject(new Error('Port is destroyed'));
-        }
-        return new Promise((resolve, reject) => {
-            this._serialport.open((error) => {
-                if (error) {
-                    reject(error);
-                }
-                else {
-                    this._serialport.on('data', (data) => {
-                        this.emit('data', data, (data) => this.write(data));
-                    });
-                    this._serialport.on('error', (error) => {
-                        this.emit('error', error);
-                    });
-                    this._serialport.on('close', () => {
-                        this._serialport.removeAllListeners();
-                        this.emit('close');
-                    });
-                    resolve();
-                }
-            });
-        });
-    }
-    write(data) {
-        return new Promise((resolve, reject) => {
-            if (this.isOpen) {
-                this._serialport.write(data, (error) => {
-                    if (error) {
-                        reject(error);
-                    }
-                    else {
-                        this.emit('write', data);
-                        resolve();
-                    }
-                });
-            }
-            else {
-                reject(new Error('Port is not open'));
-            }
-        });
-    }
-    close() {
-        return new Promise((resolve) => {
-            this._serialport.removeAllListeners();
-            this._serialport.close(() => {
-                resolve();
-            });
-        });
-    }
-    destroy() {
-        this._destroyed = true;
-        this.removeAllListeners();
-        return this.close();
-    }
-}
-
-class TcpClientPhysicalLayer extends AbstractPhysicalLayer {
-    get isOpen() {
-        return this._isOpen;
-    }
-    get destroyed() {
-        return this._destroyed;
-    }
-    constructor(options) {
-        super();
-        Object.defineProperty(this, "TYPE", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: 'NET'
-        });
-        Object.defineProperty(this, "_socket", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "_isOpen", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: false
-        });
-        Object.defineProperty(this, "_destroyed", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: false
-        });
-        this._socket = new Socket(options);
-    }
-    open(options) {
-        if (this.destroyed) {
-            return Promise.reject(new Error('Port is destroyed'));
-        }
-        return new Promise((resolve, reject) => {
-            let called = false;
-            this._socket.connect(options !== null && options !== void 0 ? options : { port: 502 }, () => {
-                called = true;
-                this._isOpen = true;
-                this._socket.on('data', (data) => {
-                    this.emit('data', data, (data) => this.write(data));
-                });
-                this._socket.on('close', () => {
-                    this._isOpen = false;
-                    this._socket.removeAllListeners();
-                    this.emit('close');
-                });
-                resolve();
-            });
-            this._socket.on('error', (error) => {
-                if (called) {
-                    this.emit('error', error);
-                }
-                else {
-                    reject(error);
-                }
-            });
-        });
-    }
-    write(data) {
-        return new Promise((resolve, reject) => {
-            if (this.isOpen) {
-                this._socket.write(data, (error) => {
-                    if (error) {
-                        reject(error);
-                    }
-                    else {
-                        this.emit('write', data);
-                        resolve();
-                    }
-                });
-            }
-            else {
-                reject(new Error('Port is not open'));
-            }
-        });
-    }
-    close() {
-        return new Promise((resolve) => {
-            this._isOpen = false;
-            this._socket.removeAllListeners();
-            this._socket.destroy();
-            resolve();
-        });
-    }
-    destroy() {
-        this._destroyed = true;
-        this.removeAllListeners();
-        return this.close();
-    }
-}
-
-class TcpServerPhysicalLayer extends AbstractPhysicalLayer {
-    get isOpen() {
-        return this._isOpen;
-    }
-    get destroyed() {
-        return this._destroyed;
-    }
-    constructor(options) {
-        super();
-        Object.defineProperty(this, "TYPE", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: 'NET'
-        });
-        Object.defineProperty(this, "_server", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "_isOpen", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: false
-        });
-        Object.defineProperty(this, "_destroyed", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: false
-        });
-        Object.defineProperty(this, "_sockets", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: new Set()
-        });
-        this._server = createServer(options, (socket) => {
-            this._sockets.add(socket);
-            socket.on('data', (data) => {
-                this.emit('data', data, (data) => new Promise((resolve, reject) => {
-                    socket.write(data, (error) => {
-                        if (error) {
-                            reject(error);
-                        }
-                        else {
-                            resolve();
-                        }
-                    });
-                }));
-            });
-            socket.once('close', () => {
-                socket.removeAllListeners();
-                this._sockets.delete(socket);
-            });
-        });
-    }
-    open(options) {
-        if (this.destroyed) {
-            return Promise.reject(new Error('Port is destroyed'));
-        }
-        return new Promise((resolve, reject) => {
-            var _a;
-            let called = false;
-            this._server.listen(Object.assign(Object.assign({}, options), { port: (_a = options === null || options === void 0 ? void 0 : options.port) !== null && _a !== void 0 ? _a : 502 }), () => {
-                called = true;
-                this._isOpen = true;
-                this._sockets.clear();
-                this._server.on('close', () => {
-                    this._isOpen = false;
-                    this._server.removeAllListeners();
-                    for (const socket of this._sockets) {
-                        socket.removeAllListeners();
-                    }
-                    this.emit('close');
-                });
-                resolve();
-            });
-            this._server.on('error', (error) => {
-                if (called) {
-                    this.emit('error', error);
-                }
-                else {
-                    reject(error);
-                }
-            });
-        });
-    }
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    write(data) {
-        return new Promise((resolve, reject) => {
-            reject(new Error('Not supported'));
-        });
-    }
-    close() {
-        return new Promise((resolve) => {
-            this._isOpen = false;
-            this._server.removeAllListeners();
-            for (const socket of this._sockets) {
-                socket.removeAllListeners();
-            }
-            this._server.close(() => {
-                resolve();
-            });
-        });
-    }
-    destroy() {
-        this._destroyed = true;
-        this.removeAllListeners();
-        return this.close();
-    }
-}
-
-class UdpPhysicalLayer extends AbstractPhysicalLayer {
-    get isOpen() {
-        return this._isOpen;
-    }
-    get destroyed() {
-        return this._destroyed;
-    }
-    /**
-     *
-     * @param options
-     * @param remote If omitted, as server.
-     * Otherwise as client.
-     */
-    constructor(options, remote) {
-        var _a, _b;
-        super();
-        Object.defineProperty(this, "TYPE", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: 'NET'
-        });
-        Object.defineProperty(this, "_socket", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "_isOpen", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: false
-        });
-        Object.defineProperty(this, "_destroyed", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: false
-        });
-        Object.defineProperty(this, "_port", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "_address", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "isServer", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this._socket = createSocket(Object.assign(Object.assign({}, options), { type: (_a = options === null || options === void 0 ? void 0 : options.type) !== null && _a !== void 0 ? _a : 'udp4' }), (msg, rinfo) => {
-            this.emit('data', msg, (data) => new Promise((resolve, reject) => {
-                this._socket.send(data, rinfo.port, rinfo.address, (error) => {
-                    if (error) {
-                        reject(error);
-                    }
-                    else {
-                        resolve();
-                    }
-                });
-            }));
-        });
-        this.isServer = !remote;
-        this._port = (_b = remote === null || remote === void 0 ? void 0 : remote.port) !== null && _b !== void 0 ? _b : 502;
-        this._address = remote === null || remote === void 0 ? void 0 : remote.address;
-    }
-    open(options) {
-        if (this.destroyed) {
-            return Promise.reject(new Error('Port is destroyed'));
-        }
-        return new Promise((resolve, reject) => {
-            var _a;
-            if (this.isServer) {
-                let called = false;
-                this._socket.bind(Object.assign(Object.assign({}, options), { port: (_a = options === null || options === void 0 ? void 0 : options.port) !== null && _a !== void 0 ? _a : 502 }), () => {
-                    called = true;
-                    this._isOpen = true;
-                    this._socket.on('close', () => {
-                        this._isOpen = false;
-                        this._socket.removeAllListeners();
-                        this.emit('close');
-                    });
-                    resolve();
-                });
-                this._socket.on('error', (error) => {
-                    if (called) {
-                        this.emit('error', error);
-                    }
-                    else {
-                        reject(error);
-                    }
-                });
-            }
-            else {
-                this._isOpen = true;
-                resolve();
-            }
-        });
-    }
-    write(data) {
-        return new Promise((resolve, reject) => {
-            if (this.isOpen) {
-                this._socket.send(data, this._port, this._address, (error) => {
-                    if (error) {
-                        reject(error);
-                    }
-                    else {
-                        this.emit('write', data);
-                        resolve();
-                    }
-                });
-            }
-            else {
-                reject(new Error('Port is not open'));
-            }
-        });
-    }
-    close() {
-        return new Promise((resolve) => {
-            this._isOpen = false;
-            this._socket.removeAllListeners();
-            this._socket.close(() => {
-                resolve();
-            });
-        });
-    }
-    destroy() {
-        this._destroyed = true;
-        this.removeAllListeners();
-        return this.close();
-    }
-}
-
-class AbstractApplicationLayer extends EventEmitter {
-}
-
-function checkRange(value, range) {
-    if (range) {
-        if (typeof range[0] === 'number' && typeof range[1] === 'number') {
-            if (range[0] < range[1]) {
-                return (Array.isArray(value) ? value : [value]).every((n) => n >= range[0] && n <= range[1]);
-            }
-        }
-        else if (range.length > 0) {
-            for (const r of range) {
-                if (r[0] < r[1]) {
-                    if ((Array.isArray(value) ? value : [value]).every((n) => n >= r[0] && n <= r[1])) {
-                        return true;
-                    }
-                }
-            }
-            return false;
-        }
-    }
-    return true;
-}
-
-const TABLE = [
-    0x0000, 0xc0c1, 0xc181, 0x0140, 0xc301, 0x03c0, 0x0280, 0xc241, 0xc601, 0x06c0, 0x0780, 0xc741, 0x0500, 0xc5c1, 0xc481, 0x0440, 0xcc01,
-    0x0cc0, 0x0d80, 0xcd41, 0x0f00, 0xcfc1, 0xce81, 0x0e40, 0x0a00, 0xcac1, 0xcb81, 0x0b40, 0xc901, 0x09c0, 0x0880, 0xc841, 0xd801, 0x18c0,
-    0x1980, 0xd941, 0x1b00, 0xdbc1, 0xda81, 0x1a40, 0x1e00, 0xdec1, 0xdf81, 0x1f40, 0xdd01, 0x1dc0, 0x1c80, 0xdc41, 0x1400, 0xd4c1, 0xd581,
-    0x1540, 0xd701, 0x17c0, 0x1680, 0xd641, 0xd201, 0x12c0, 0x1380, 0xd341, 0x1100, 0xd1c1, 0xd081, 0x1040, 0xf001, 0x30c0, 0x3180, 0xf141,
-    0x3300, 0xf3c1, 0xf281, 0x3240, 0x3600, 0xf6c1, 0xf781, 0x3740, 0xf501, 0x35c0, 0x3480, 0xf441, 0x3c00, 0xfcc1, 0xfd81, 0x3d40, 0xff01,
-    0x3fc0, 0x3e80, 0xfe41, 0xfa01, 0x3ac0, 0x3b80, 0xfb41, 0x3900, 0xf9c1, 0xf881, 0x3840, 0x2800, 0xe8c1, 0xe981, 0x2940, 0xeb01, 0x2bc0,
-    0x2a80, 0xea41, 0xee01, 0x2ec0, 0x2f80, 0xef41, 0x2d00, 0xedc1, 0xec81, 0x2c40, 0xe401, 0x24c0, 0x2580, 0xe541, 0x2700, 0xe7c1, 0xe681,
-    0x2640, 0x2200, 0xe2c1, 0xe381, 0x2340, 0xe101, 0x21c0, 0x2080, 0xe041, 0xa001, 0x60c0, 0x6180, 0xa141, 0x6300, 0xa3c1, 0xa281, 0x6240,
-    0x6600, 0xa6c1, 0xa781, 0x6740, 0xa501, 0x65c0, 0x6480, 0xa441, 0x6c00, 0xacc1, 0xad81, 0x6d40, 0xaf01, 0x6fc0, 0x6e80, 0xae41, 0xaa01,
-    0x6ac0, 0x6b80, 0xab41, 0x6900, 0xa9c1, 0xa881, 0x6840, 0x7800, 0xb8c1, 0xb981, 0x7940, 0xbb01, 0x7bc0, 0x7a80, 0xba41, 0xbe01, 0x7ec0,
-    0x7f80, 0xbf41, 0x7d00, 0xbdc1, 0xbc81, 0x7c40, 0xb401, 0x74c0, 0x7580, 0xb541, 0x7700, 0xb7c1, 0xb681, 0x7640, 0x7200, 0xb2c1, 0xb381,
-    0x7340, 0xb101, 0x71c0, 0x7080, 0xb041, 0x5000, 0x90c1, 0x9181, 0x5140, 0x9301, 0x53c0, 0x5280, 0x9241, 0x9601, 0x56c0, 0x5780, 0x9741,
-    0x5500, 0x95c1, 0x9481, 0x5440, 0x9c01, 0x5cc0, 0x5d80, 0x9d41, 0x5f00, 0x9fc1, 0x9e81, 0x5e40, 0x5a00, 0x9ac1, 0x9b81, 0x5b40, 0x9901,
-    0x59c0, 0x5880, 0x9841, 0x8801, 0x48c0, 0x4980, 0x8941, 0x4b00, 0x8bc1, 0x8a81, 0x4a40, 0x4e00, 0x8ec1, 0x8f81, 0x4f40, 0x8d01, 0x4dc0,
-    0x4c80, 0x8c41, 0x4400, 0x84c1, 0x8581, 0x4540, 0x8701, 0x47c0, 0x4680, 0x8641, 0x8201, 0x42c0, 0x4380, 0x8341, 0x4100, 0x81c1, 0x8081,
-    0x4040,
-];
-function crc(data) {
-    let crc = 0xffff;
-    for (let index = 0; index < data.length; index++) {
-        crc = (TABLE[(crc ^ data[index]) & 0xff] ^ (crc >> 8)) & 0xffff;
-    }
-    return crc;
-}
-
-/**
- * Get time interval between message frames witch well-known as 3.5T.
- * @param baudRate Serial port baud rate.
- * @param {number} [approximation=48] Approximate number of bits corresponding to 3.5T.
- * @returns `ms`.
- */
-function getThreePointFiveT(baudRate, approximation = 48) {
-    return (approximation * 1000) / baudRate;
-}
-
-function lrc(data) {
-    return (~data.reduce((sum, n) => sum + n, 0) + 1) & 0xff;
-}
-
-class RtuApplicationLayer extends AbstractApplicationLayer {
-    constructor(physicalLayer, 
-    /**
-     * The time interval between two frames, support two formats:
-     * - bit: `48bit` as default
-     * - millisecond: `20ms`
-     */
-    intervalBetweenFrames) {
-        super();
-        Object.defineProperty(this, "_waitingResponse", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "_timerThreePointFive", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "_bufferRx", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: Buffer.alloc(0)
-        });
-        Object.defineProperty(this, "_removeAllListeners", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: []
-        });
-        let threePointFiveT = 0;
-        if (physicalLayer.TYPE === 'SERIAL') {
-            if (intervalBetweenFrames && intervalBetweenFrames.endsWith('ms')) {
-                threePointFiveT = Number(intervalBetweenFrames.slice(0, -2));
-            }
-            else {
-                threePointFiveT = Math.ceil(physicalLayer.baudRate > 19200
-                    ? 1.8
-                    : getThreePointFiveT(physicalLayer.baudRate, intervalBetweenFrames ? Number(intervalBetweenFrames.slice(0, -3)) : 48));
-            }
-        }
-        const handleData = (data, response) => {
-            this._bufferRx = Buffer.concat([this._bufferRx, data]);
-            if (this._waitingResponse) {
-                this.framing(this._bufferRx, (error, frame) => {
-                    if (error && error.message === 'Insufficient data length') {
-                        return;
-                    }
-                    this._waitingResponse.callback(error, frame);
-                    this._bufferRx = Buffer.alloc(0);
-                });
-            }
-            else {
-                clearTimeout(this._timerThreePointFive);
-                const handleData = () => {
-                    this.framing(this._bufferRx, (error, frame) => {
-                        if (!error) {
-                            this.emit('framing', frame, response);
-                        }
-                        this._bufferRx = Buffer.alloc(0);
-                    });
-                };
-                if (threePointFiveT) {
-                    this._timerThreePointFive = setTimeout(handleData, threePointFiveT);
-                }
-                else {
-                    handleData();
-                }
-            }
-        };
-        physicalLayer.on('data', handleData);
-        this._removeAllListeners.push(() => {
-            physicalLayer.removeListener('data', handleData);
-        });
-        const handleClose = () => {
-            clearTimeout(this._timerThreePointFive);
-            this._bufferRx = Buffer.alloc(0);
-        };
-        physicalLayer.on('close', handleClose);
-        this._removeAllListeners.push(() => {
-            physicalLayer.removeListener('close', handleClose);
-        });
-    }
-    framing(buffer, callback) {
-        if (buffer.length >= 4) {
-            const frame = {
-                unit: buffer[0],
-                fc: buffer[1],
-                data: Array.from(buffer.subarray(2, buffer.length - 2)),
-                buffer,
-            };
-            if (this._waitingResponse) {
-                for (const check of this._waitingResponse.preCheck) {
-                    const res = check(frame);
-                    if (typeof res === 'undefined') {
-                        callback(new Error('Insufficient data length'));
-                        return;
-                    }
-                    if (typeof res === 'number') {
-                        if (res < frame.data.length) {
-                            callback(new Error('Insufficient data length'));
-                            return;
-                        }
-                        if (res !== frame.data.length) {
-                            callback(new Error('Invalid response'));
-                            return;
-                        }
-                    }
-                    if (!res) {
-                        callback(new Error('Invalid response'));
-                        return;
-                    }
-                }
-            }
-            const crcPassed = buffer.readUInt16LE(buffer.length - 2) === crc(buffer.subarray(0, buffer.length - 2));
-            if (crcPassed) {
-                callback(null, frame);
-            }
-            else {
-                callback(new Error('CRC check failed'));
-            }
-        }
-        else {
-            callback(new Error('Insufficient data length'));
-        }
-    }
-    startWaitingResponse(preCheck, callback) {
-        this._waitingResponse = { preCheck, callback };
-        clearTimeout(this._timerThreePointFive);
-        this._bufferRx = Buffer.alloc(0);
-    }
-    stopWaitingResponse() {
-        this._waitingResponse = undefined;
-    }
-    encode(data) {
-        const buffer = Buffer.alloc(data.data.length + 4);
-        buffer.writeUInt8(data.unit, 0);
-        buffer.writeUInt8(data.fc, 1);
-        data.data.forEach((num, index) => {
-            buffer.writeUInt8(num, 2 + index);
-        });
-        buffer.writeUInt16LE(crc(buffer.subarray(0, -2)), buffer.length - 2);
-        return buffer;
-    }
-    destroy() {
-        this.removeAllListeners();
-        for (const removeAllListener of this._removeAllListeners) {
-            removeAllListener();
-        }
-        clearTimeout(this._timerThreePointFive);
-    }
-}
-
-const CHAR_CODE = {
-    COLON: ':'.charCodeAt(0),
-    CR: '\r'.charCodeAt(0),
-    LF: '\n'.charCodeAt(0),
-};
-class AsciiApplicationLayer extends AbstractApplicationLayer {
-    constructor(physicalLayer) {
-        super();
-        Object.defineProperty(this, "_waitingResponse", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "_status", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: 'idle'
-        });
-        Object.defineProperty(this, "_frame", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: []
-        });
-        Object.defineProperty(this, "_removeAllListeners", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: []
-        });
-        const handleData = (data, response) => {
-            data.forEach((value) => {
-                switch (this._status) {
-                    case 'idle': {
-                        if (value === CHAR_CODE.COLON) {
-                            this._status = 'reception';
-                            this._frame = [];
-                        }
-                        break;
-                    }
-                    case 'reception': {
-                        if (value === CHAR_CODE.COLON) {
-                            this._frame = [];
-                        }
-                        else if (value === CHAR_CODE.CR) {
-                            this._status = 'waiting end';
-                        }
-                        else {
-                            this._frame.push(value);
-                        }
-                        break;
-                    }
-                    case 'waiting end': {
-                        if (value === CHAR_CODE.COLON) {
-                            this._status = 'reception';
-                            this._frame = [];
-                        }
-                        else {
-                            this._status = 'idle';
-                            if (value === CHAR_CODE.LF) {
-                                this.framing(Buffer.from(this._frame), (error, frame) => {
-                                    if (this._waitingResponse) {
-                                        this._waitingResponse.callback(error, frame);
-                                    }
-                                    else if (!error) {
-                                        this.emit('framing', frame, response);
-                                    }
-                                });
-                            }
-                        }
-                        break;
-                    }
-                }
-            });
-        };
-        physicalLayer.on('data', handleData);
-        this._removeAllListeners.push(() => {
-            physicalLayer.removeListener('data', handleData);
-        });
-        const handleClose = () => {
-            this._status = 'idle';
-            this._frame = [];
-        };
-        physicalLayer.on('close', handleClose);
-        this._removeAllListeners.push(() => {
-            physicalLayer.removeListener('close', handleClose);
-        });
-    }
-    framing(_buffer, callback) {
-        if (_buffer.length >= 6) {
-            if (_buffer.length % 2 === 0) {
-                const ascii = [];
-                let num = '';
-                for (const value of _buffer) {
-                    num += String.fromCharCode(value);
-                    if (num.length === 2) {
-                        ascii.push(Number('0x' + num));
-                        num = '';
-                    }
-                }
-                const buffer = Buffer.from(ascii);
-                const frame = {
-                    unit: buffer[0],
-                    fc: buffer[1],
-                    data: Array.from(buffer.subarray(2, buffer.length - 1)),
-                    buffer: _buffer,
-                };
-                if (this._waitingResponse) {
-                    for (const check of this._waitingResponse.preCheck) {
-                        const res = check(frame);
-                        if (typeof res === 'undefined') {
-                            callback(new Error('Insufficient data length'));
-                            return;
-                        }
-                        if (typeof res === 'number') {
-                            if (res < frame.data.length) {
-                                callback(new Error('Insufficient data length'));
-                                return;
-                            }
-                            if (res !== frame.data.length) {
-                                callback(new Error('Invalid response'));
-                                return;
-                            }
-                        }
-                        if (!res) {
-                            callback(new Error('Invalid response'));
-                            return;
-                        }
-                    }
-                }
-                const lrcPassed = buffer[buffer.length - 1] === lrc(buffer.subarray(0, buffer.length - 1));
-                if (lrcPassed) {
-                    callback(null, frame);
-                }
-                else {
-                    callback(new Error('LRC check failed'));
-                }
-            }
-            else {
-                callback(new Error('Invalid data'));
-            }
-        }
-        else {
-            callback(new Error('Insufficient data length'));
-        }
-    }
-    startWaitingResponse(preCheck, callback) {
-        this._waitingResponse = { preCheck, callback };
-        this._status = 'idle';
-        this._frame = [];
-    }
-    stopWaitingResponse() {
-        this._waitingResponse = undefined;
-    }
-    encode(data) {
-        const buffer = Buffer.alloc(data.data.length + 3);
-        buffer.writeUInt8(data.unit, 0);
-        buffer.writeUInt8(data.fc, 1);
-        data.data.forEach((num, index) => {
-            buffer.writeUInt8(num, 2 + index);
-        });
-        buffer.writeUInt8(lrc(buffer.subarray(0, -1)), buffer.length - 1);
-        let frame = ':';
-        for (const value of buffer) {
-            frame += value.toString(16).toUpperCase().padStart(2, '0');
-        }
-        frame += '\r\n';
-        return Buffer.from(frame);
-    }
-    destroy() {
-        this.removeAllListeners();
-        for (const removeAllListener of this._removeAllListeners) {
-            removeAllListener();
-        }
-    }
-}
-
-class TcpApplicationLayer extends AbstractApplicationLayer {
-    constructor(physicalLayer) {
-        super();
-        Object.defineProperty(this, "_waitingResponse", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "_transactionId", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: 1
-        });
-        Object.defineProperty(this, "_removeAllListeners", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: []
-        });
-        const handleData = (data, response) => {
-            this.framing(data, (error, frame) => {
-                if (this._waitingResponse) {
-                    this._waitingResponse.callback(error, frame);
-                }
-                else if (!error) {
-                    this.emit('framing', frame, response);
-                }
-            });
-        };
-        physicalLayer.on('data', handleData);
-        this._removeAllListeners.push(() => {
-            physicalLayer.removeListener('data', handleData);
-        });
-    }
-    framing(buffer, callback) {
-        if (buffer.length >= 8) {
-            if (buffer[2] === 0 && buffer[3] === 0 && buffer.readUInt16BE(4) === buffer.length - 6) {
-                const frame = {
-                    transaction: buffer.readUInt16BE(0),
-                    unit: buffer[6],
-                    fc: buffer[7],
-                    data: Array.from(buffer.subarray(8)),
-                    buffer,
-                };
-                if (this._waitingResponse) {
-                    for (const check of this._waitingResponse.preCheck) {
-                        const res = check(frame);
-                        if (typeof res === 'undefined') {
-                            callback(new Error('Insufficient data length'));
-                            return;
-                        }
-                        if (typeof res === 'number') {
-                            if (res < frame.data.length) {
-                                callback(new Error('Insufficient data length'));
-                                return;
-                            }
-                            if (res !== frame.data.length) {
-                                callback(new Error('Invalid response'));
-                                return;
-                            }
-                        }
-                        if (!res) {
-                            callback(new Error('Invalid response'));
-                            return;
-                        }
-                    }
-                }
-                callback(null, frame);
-            }
-            else {
-                callback(new Error('Invalid data'));
-            }
-        }
-        else {
-            callback(new Error('Insufficient data length'));
-        }
-    }
-    startWaitingResponse(preCheck, callback) {
-        this._waitingResponse = { preCheck, callback };
-    }
-    stopWaitingResponse() {
-        this._waitingResponse = undefined;
-    }
-    encode(data) {
-        var _a;
-        const buffer = Buffer.alloc(data.data.length + 8);
-        buffer.writeUInt16BE((_a = data.transaction) !== null && _a !== void 0 ? _a : this._transactionId, 0);
-        buffer.writeUInt16BE(0, 2);
-        buffer.writeUInt16BE(data.data.length + 2, 4);
-        buffer.writeUInt8(data.unit, 6);
-        buffer.writeUInt8(data.fc, 7);
-        data.data.forEach((num, index) => {
-            buffer.writeUInt8(num, 8 + index);
-        });
-        this._transactionId = (this._transactionId + 1) % 256 || 1;
-        return buffer;
-    }
-    destroy() {
-        this.removeAllListeners();
-        for (const removeAllListener of this._removeAllListeners) {
-            removeAllListener();
-        }
-    }
-}
-
-class ModbusMaster extends EventEmitter {
-    get isOpen() {
-        return this.physicalLayer.isOpen;
-    }
-    get destroyed() {
-        return this.physicalLayer.destroyed;
-    }
-    constructor(applicationLayer, physicalLayer, timeout = 1000) {
-        super();
-        Object.defineProperty(this, "applicationLayer", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: applicationLayer
-        });
-        Object.defineProperty(this, "physicalLayer", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: physicalLayer
-        });
-        Object.defineProperty(this, "timeout", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: timeout
-        });
-        Object.defineProperty(this, "writeFC1", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "writeFC2", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "writeFC3", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "writeFC4", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "writeFC5", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "writeFC6", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "writeFC15", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "writeFC16", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "handleFC17", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "handleFC22", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "handleFC23", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "handleFC43_14", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.writeFC1 = this.readCoils;
-        this.writeFC2 = this.readDiscreteInputs;
-        this.writeFC3 = this.readHoldingRegisters;
-        this.writeFC4 = this.readInputRegisters;
-        this.writeFC5 = this.writeSingleCoil;
-        this.writeFC6 = this.writeSingleRegister;
-        this.writeFC15 = this.writeMultipleCoils;
-        this.writeFC16 = this.writeMultipleRegisters;
-        this.handleFC17 = this.reportServerId;
-        this.handleFC22 = this.maskWriteRegister;
-        this.handleFC23 = this.readAndWriteMultipleRegisters;
-        this.handleFC43_14 = this.readDeviceIdentification;
-        physicalLayer.on('error', (error) => {
-            this.emit('error', error);
-        });
-        physicalLayer.on('close', () => {
-            this.emit('close');
-        });
-    }
-    waitResponse(request, response, timeout) {
-        return new Promise((resolve, reject) => {
-            this.physicalLayer
-                .write(request.data)
-                .then(() => {
-                if (request.broadcast) {
-                    resolve();
-                }
-                else {
-                    const tid = setTimeout(() => {
-                        this.applicationLayer.stopWaitingResponse();
-                        reject(new Error('Timeout'));
-                    }, timeout);
-                    this.applicationLayer.startWaitingResponse(response.preCheck, (error, frame) => {
-                        clearTimeout(tid);
-                        this.applicationLayer.stopWaitingResponse();
-                        if (error) {
-                            reject(error);
-                        }
-                        else {
-                            resolve(frame);
-                        }
-                    });
-                }
-            })
-                .catch((error) => {
-                reject(error);
-            });
-        });
-    }
-    writeFC1Or2(unit, fc, address, length, timeout) {
-        const byteCount = Math.ceil(length / 8);
-        const bufferTx = Buffer.alloc(4);
-        bufferTx.writeUInt16BE(address, 0);
-        bufferTx.writeUInt16BE(length, 2);
-        return this.waitResponse({
-            data: this.applicationLayer.encode({
-                unit,
-                fc,
-                data: Array.from(bufferTx),
-            }),
-            broadcast: unit === 0,
-        }, {
-            preCheck: [(frame) => frame.unit === unit && frame.fc === fc, () => 1 + byteCount, (frame) => frame.data[0] === byteCount],
-        }, timeout).then((frame) => {
-            if (frame) {
-                return Object.assign(Object.assign({}, frame), { data: Array.from({ length }).map((_, index) => (frame.data[1 + ~~(index / 8)] & (1 << index % 8)) > 0) });
-            }
-        });
-    }
-    readCoils(unit, address, length, timeout = this.timeout) {
-        return this.writeFC1Or2(unit, 0x01, address, length, timeout);
-    }
-    readDiscreteInputs(unit, address, length, timeout = this.timeout) {
-        return this.writeFC1Or2(unit, 0x02, address, length, timeout);
-    }
-    writeFC3Or4(unit, fc, address, length, timeout) {
-        const byteCount = length * 2;
-        const bufferTx = Buffer.alloc(4);
-        bufferTx.writeUInt16BE(address, 0);
-        bufferTx.writeUInt16BE(length, 2);
-        return this.waitResponse({
-            data: this.applicationLayer.encode({
-                unit,
-                fc,
-                data: Array.from(bufferTx),
-            }),
-            broadcast: unit === 0,
-        }, {
-            preCheck: [(frame) => frame.unit === unit && frame.fc === fc, () => 1 + byteCount, (frame) => frame.data[0] === byteCount],
-        }, timeout).then((frame) => {
-            if (frame) {
-                const bufferRx = Buffer.from(frame.data.slice(1));
-                return Object.assign(Object.assign({}, frame), { data: Array.from({ length }).map((_, index) => bufferRx.readUInt16BE(index * 2)) });
-            }
-        });
-    }
-    readHoldingRegisters(unit, address, length, timeout = this.timeout) {
-        return this.writeFC3Or4(unit, 0x03, address, length, timeout);
-    }
-    readInputRegisters(unit, address, length, timeout = this.timeout) {
-        return this.writeFC3Or4(unit, 0x04, address, length, timeout);
-    }
-    writeSingleCoil(unit, address, value, timeout = this.timeout) {
-        const fc = 0x05;
-        const bufferTx = Buffer.alloc(4);
-        bufferTx.writeUInt16BE(address, 0);
-        bufferTx.writeUInt16BE(value ? 0xff00 : 0x0000, 2);
-        return this.waitResponse({
-            data: this.applicationLayer.encode({
-                unit,
-                fc,
-                data: Array.from(bufferTx),
-            }),
-            broadcast: unit === 0,
-        }, {
-            preCheck: [
-                (frame) => frame.unit === unit && frame.fc === fc,
-                () => bufferTx.length,
-                (frame) => frame.data.every((v, i) => v === bufferTx[i]),
-            ],
-        }, timeout).then((frame) => {
-            if (frame) {
-                return Object.assign(Object.assign({}, frame), { data: value });
-            }
-        });
-    }
-    writeSingleRegister(unit, address, value, timeout = this.timeout) {
-        const fc = 0x06;
-        const bufferTx = Buffer.alloc(4);
-        bufferTx.writeUInt16BE(address, 0);
-        bufferTx.writeUInt16BE(value, 2);
-        return this.waitResponse({
-            data: this.applicationLayer.encode({
-                unit,
-                fc,
-                data: Array.from(bufferTx),
-            }),
-            broadcast: unit === 0,
-        }, {
-            preCheck: [
-                (frame) => frame.unit === unit && frame.fc === fc,
-                () => bufferTx.length,
-                (frame) => frame.data.every((v, i) => v === bufferTx[i]),
-            ],
-        }, timeout).then((frame) => {
-            if (frame) {
-                return Object.assign(Object.assign({}, frame), { data: value });
-            }
-        });
-    }
-    writeMultipleCoils(unit, address, value, timeout = this.timeout) {
-        const fc = 0x0f;
-        const byteCount = Math.ceil(value.length / 8);
-        const bufferTx = Buffer.alloc(5 + byteCount);
-        bufferTx.writeUInt16BE(address, 0);
-        bufferTx.writeUInt16BE(value.length, 2);
-        bufferTx.writeUInt8(byteCount, 4);
-        value.forEach((v, i) => {
-            if (v) {
-                bufferTx[5 + ~~(i / 8)] |= 1 << i % 8;
-            }
-        });
-        return this.waitResponse({
-            data: this.applicationLayer.encode({
-                unit,
-                fc,
-                data: Array.from(bufferTx),
-            }),
-            broadcast: unit === 0,
-        }, {
-            preCheck: [(frame) => frame.unit === unit && frame.fc === fc, () => 4, (frame) => frame.data.every((v, i) => v === bufferTx[i])],
-        }, timeout).then((frame) => {
-            if (frame) {
-                return Object.assign(Object.assign({}, frame), { data: value });
-            }
-        });
-    }
-    writeMultipleRegisters(unit, address, value, timeout = this.timeout) {
-        const fc = 0x10;
-        const byteCount = value.length * 2;
-        const bufferTx = Buffer.alloc(5 + byteCount);
-        bufferTx.writeUInt16BE(address, 0);
-        bufferTx.writeUInt16BE(value.length, 2);
-        bufferTx.writeUInt8(byteCount, 4);
-        value.forEach((v, i) => {
-            bufferTx.writeUInt16BE(v, 5 + i * 2);
-        });
-        return this.waitResponse({
-            data: this.applicationLayer.encode({
-                unit,
-                fc,
-                data: Array.from(bufferTx),
-            }),
-            broadcast: unit === 0,
-        }, {
-            preCheck: [(frame) => frame.unit === unit && frame.fc === fc, () => 4, (frame) => frame.data.every((v, i) => v === bufferTx[i])],
-        }, timeout).then((frame) => {
-            if (frame) {
-                return Object.assign(Object.assign({}, frame), { data: value });
-            }
-        });
-    }
-    reportServerId(unit, timeout = this.timeout) {
-        const fc = 0x11;
-        return this.waitResponse({
-            data: this.applicationLayer.encode({
-                unit,
-                fc,
-                data: [],
-            }),
-            broadcast: unit === 0,
-        }, {
-            preCheck: [
-                (frame) => frame.unit === unit && frame.fc === fc,
-                (frame) => {
-                    if (frame.data.length >= 3) {
-                        return 1 + frame.data[0];
-                    }
-                },
-            ],
-        }, timeout).then((frame) => {
-            if (frame) {
-                return Object.assign(Object.assign({}, frame), { data: {
-                        serverId: frame.data[1],
-                        runIndicatorStatus: frame.data[2] === 0xff,
-                        additionalData: frame.data.slice(3),
-                    } });
-            }
-        });
-    }
-    maskWriteRegister(unit, address, andMask, orMask, timeout = this.timeout) {
-        const fc = 0x16;
-        const bufferTx = Buffer.alloc(6);
-        bufferTx.writeUInt16BE(address, 0);
-        bufferTx.writeUInt16BE(andMask, 2);
-        bufferTx.writeUInt16BE(orMask, 4);
-        return this.waitResponse({
-            data: this.applicationLayer.encode({
-                unit,
-                fc,
-                data: Array.from(bufferTx),
-            }),
-            broadcast: unit === 0,
-        }, {
-            preCheck: [(frame) => frame.unit === unit && frame.fc === fc, () => 6, (frame) => frame.data.every((v, i) => v === bufferTx[i])],
-        }, timeout).then((frame) => {
-            if (frame) {
-                return Object.assign(Object.assign({}, frame), { data: { andMask, orMask } });
-            }
-        });
-    }
-    readAndWriteMultipleRegisters(unit, read, write, timeout = this.timeout) {
-        const fc = 0x17;
-        const byteCount = write.value.length * 2;
-        const bufferTx = Buffer.alloc(9 + byteCount);
-        bufferTx.writeUInt16BE(read.address, 0);
-        bufferTx.writeUInt16BE(read.length, 2);
-        bufferTx.writeUInt16BE(write.address, 4);
-        bufferTx.writeUInt16BE(write.value.length, 6);
-        bufferTx.writeUInt8(byteCount, 8);
-        write.value.forEach((v, i) => {
-            bufferTx.writeUInt16BE(v, 9 + i * 2);
-        });
-        return this.waitResponse({
-            data: this.applicationLayer.encode({
-                unit,
-                fc,
-                data: Array.from(bufferTx),
-            }),
-            broadcast: unit === 0,
-        }, {
-            preCheck: [(frame) => frame.unit === unit && frame.fc === fc, () => 1 + byteCount, (frame) => frame.data[0] === byteCount],
-        }, timeout).then((frame) => {
-            if (frame) {
-                const bufferRx = Buffer.from(frame.data.slice(1));
-                return Object.assign(Object.assign({}, frame), { data: Array.from({ length: read.length }).map((_, index) => bufferRx.readUInt16BE(index * 2)) });
-            }
-        });
-    }
-    readDeviceIdentification(unit, readDeviceIDCode, objectId, timeout = this.timeout) {
-        const fc = 0x2b;
-        return this.waitResponse({
-            data: this.applicationLayer.encode({
-                unit,
-                fc,
-                data: [0x0e, readDeviceIDCode, objectId],
-            }),
-            broadcast: unit === 0,
-        }, {
-            preCheck: [
-                (frame) => frame.unit === unit && frame.fc === fc,
-                (frame) => {
-                    if (frame.data.length >= 6) {
-                        if (frame.data[0] === 0x0e && frame.data[1] === readDeviceIDCode) {
-                            const objects = [];
-                            let object = [];
-                            for (const v of frame.data.slice(6)) {
-                                switch (object.length) {
-                                    case 0:
-                                    case 1: {
-                                        object.push(v);
-                                        break;
-                                    }
-                                    case 2: {
-                                        object.push([v]);
-                                        break;
-                                    }
-                                    case 3: {
-                                        object[2].push(v);
-                                        if (object[1] === object[2].length) {
-                                            objects.push(2 + object[1]);
-                                            object = [];
-                                        }
-                                        break;
-                                    }
-                                }
-                            }
-                            if (objects.length === frame.data[5]) {
-                                return 6 + objects.reduce((previous, current) => previous + current, 0);
-                            }
-                        }
-                        else {
-                            return false;
-                        }
-                    }
-                },
-            ],
-        }, timeout).then((frame) => {
-            if (frame) {
-                const objects = [];
-                let object = [];
-                for (const v of frame.data.slice(6)) {
-                    switch (object.length) {
-                        case 0:
-                        case 1: {
-                            object.push(v);
-                            break;
-                        }
-                        case 2: {
-                            object.push([v]);
-                            break;
-                        }
-                        case 3: {
-                            object[2].push(v);
-                            if (object[1] === object[2].length) {
-                                objects.push({ id: object[0], value: Buffer.from(object[2]).toString() });
-                                object = [];
-                            }
-                            break;
-                        }
-                    }
-                }
-                return Object.assign(Object.assign({}, frame), { data: {
-                        readDeviceIDCode,
-                        conformityLevel: frame.data[2],
-                        moreFollows: frame.data[3] === 0xff,
-                        nextObjectId: frame.data[4],
-                        objects,
-                    } });
-            }
-        });
-    }
-    open(...args) {
-        return this.physicalLayer.open(...args);
-    }
-    close() {
-        return this.physicalLayer.close();
-    }
-    destroy() {
-        this.removeAllListeners();
-        this.applicationLayer.destroy();
-        return this.physicalLayer.destroy();
-    }
-}
-
-/******************************************************************************
-Copyright (c) Microsoft Corporation.
-
-Permission to use, copy, modify, and/or distribute this software for any
-purpose with or without fee is hereby granted.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-PERFORMANCE OF THIS SOFTWARE.
-***************************************************************************** */
-/* global Reflect, Promise, SuppressedError, Symbol, Iterator */
-
-
-function __awaiter(thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-}
-
-typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
-    var e = new Error(message);
-    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
-};
-
-class ModbusSlave extends EventEmitter {
-    get isOpen() {
-        return this.physicalLayer.isOpen;
-    }
-    get destroyed() {
-        return this.physicalLayer.destroyed;
-    }
-    constructor(model, applicationLayer, physicalLayer) {
-        super();
-        Object.defineProperty(this, "model", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: model
-        });
-        Object.defineProperty(this, "applicationLayer", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: applicationLayer
-        });
-        Object.defineProperty(this, "physicalLayer", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: physicalLayer
-        });
-        Object.defineProperty(this, "unit", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: 1
-        });
-        if (typeof model.unit !== 'undefined') {
-            this.unit = model.unit;
-        }
-        applicationLayer.on('framing', (frame, _response) => __awaiter(this, void 0, void 0, function* () {
-            if (!(frame.unit === 0x00 || frame.unit === this.unit)) {
-                return;
-            }
-            const response = (data) => __awaiter(this, void 0, void 0, function* () {
-                if (frame.unit === 0x00) {
-                    return;
-                }
-                try {
-                    yield _response(data);
-                }
-                catch (error) { }
-            });
-            if (model.interceptor) {
-                try {
-                    const data = yield model.interceptor(frame.fc, frame.data);
-                    if (data) {
-                        response(this.applicationLayer.encode(Object.assign(Object.assign({}, frame), { data })));
-                        return;
-                    }
-                }
-                catch (error) {
-                    this.responseError(frame, response, error);
-                    return;
-                }
-            }
-            switch (frame.fc) {
-                case 0x01: {
-                    this.handleFC1(frame, response);
-                    break;
-                }
-                case 0x02: {
-                    this.handleFC2(frame, response);
-                    break;
-                }
-                case 0x03: {
-                    this.handleFC3(frame, response);
-                    break;
-                }
-                case 0x04: {
-                    this.handleFC4(frame, response);
-                    break;
-                }
-                case 0x05: {
-                    this.handleFC5(frame, response);
-                    break;
-                }
-                case 0x06: {
-                    this.handleFC6(frame, response);
-                    break;
-                }
-                case 0x0f: {
-                    this.handleFC15(frame, response);
-                    break;
-                }
-                case 0x10: {
-                    this.handleFC16(frame, response);
-                    break;
-                }
-                case 0x11: {
-                    this.handleFC17(frame, response);
-                    break;
-                }
-                case 0x16: {
-                    this.handleFC22(frame, response);
-                    break;
-                }
-                case 0x17: {
-                    this.handleFC23(frame, response);
-                    break;
-                }
-                case 0x2b: {
-                    this.handleFC43_14(frame, response);
-                    break;
-                }
-                default: {
-                    this.responseError(frame, response, getErrorByCode(ErrorCode.ILLEGAL_FUNCTION));
-                    break;
-                }
-            }
-        }));
-        physicalLayer.on('error', (error) => {
-            this.emit('error', error);
-        });
-        physicalLayer.on('close', () => {
-            this.emit('close');
-        });
-    }
-    handleFC1(frame, response) {
-        var _a, _b;
-        if (frame.data.length === 4) {
-            if (this.model.readCoils) {
-                const bufferRx = Buffer.from(frame.data);
-                const address = bufferRx.readUInt16BE(0);
-                const length = bufferRx.readUInt16BE(2);
-                if (length >= 0x0001 && length <= 0x07d0) {
-                    if (checkRange([address, address + length], (_b = (_a = this.model).getAddressRange) === null || _b === void 0 ? void 0 : _b.call(_a).coils)) {
-                        Promise.resolve(this.model.readCoils(address, length))
-                            .then((coils) => {
-                            const bufferTx = Buffer.alloc(Math.ceil(length / 8));
-                            coils.forEach((coil, index) => {
-                                if (coil) {
-                                    bufferTx[~~(index / 8)] |= 1 << index % 8;
-                                }
-                            });
-                            response(this.applicationLayer.encode(Object.assign(Object.assign({}, frame), { data: [bufferTx.length].concat(Array.from(bufferTx)) })));
-                        })
-                            .catch((error) => {
-                            this.responseError(frame, response, error);
-                        });
-                    }
-                    else {
-                        this.responseError(frame, response, getErrorByCode(ErrorCode.ILLEGAL_DATA_ADDRESS));
-                    }
-                }
-                else {
-                    this.responseError(frame, response, getErrorByCode(ErrorCode.ILLEGAL_DATA_VALUE));
-                }
-            }
-            else {
-                this.responseError(frame, response, getErrorByCode(ErrorCode.ILLEGAL_FUNCTION));
-            }
-        }
-    }
-    handleFC2(frame, response) {
-        var _a, _b;
-        if (frame.data.length === 4) {
-            if (this.model.readDiscreteInputs) {
-                const bufferRx = Buffer.from(frame.data);
-                const address = bufferRx.readUInt16BE(0);
-                const length = bufferRx.readUInt16BE(2);
-                if (length >= 0x0001 && length <= 0x07d0) {
-                    if (checkRange([address, address + length], (_b = (_a = this.model).getAddressRange) === null || _b === void 0 ? void 0 : _b.call(_a).discreteInputs)) {
-                        Promise.resolve(this.model.readDiscreteInputs(address, length))
-                            .then((discreteInputs) => {
-                            const bufferTx = Buffer.alloc(Math.ceil(length / 8));
-                            discreteInputs.forEach((discreteInput, index) => {
-                                if (discreteInput) {
-                                    bufferTx[~~(index / 8)] |= 1 << index % 8;
-                                }
-                            });
-                            response(this.applicationLayer.encode(Object.assign(Object.assign({}, frame), { data: [bufferTx.length].concat(Array.from(bufferTx)) })));
-                        })
-                            .catch((error) => {
-                            this.responseError(frame, response, error);
-                        });
-                    }
-                    else {
-                        this.responseError(frame, response, getErrorByCode(ErrorCode.ILLEGAL_DATA_ADDRESS));
-                    }
-                }
-                else {
-                    this.responseError(frame, response, getErrorByCode(ErrorCode.ILLEGAL_DATA_VALUE));
-                }
-            }
-            else {
-                this.responseError(frame, response, getErrorByCode(ErrorCode.ILLEGAL_FUNCTION));
-            }
-        }
-    }
-    handleFC3(frame, response) {
-        var _a, _b;
-        if (frame.data.length === 4) {
-            if (this.model.readHoldingRegisters) {
-                const bufferRx = Buffer.from(frame.data);
-                const address = bufferRx.readUInt16BE(0);
-                const length = bufferRx.readUInt16BE(2);
-                if (length >= 0x0001 && length <= 0x007d) {
-                    if (checkRange([address, address + length], (_b = (_a = this.model).getAddressRange) === null || _b === void 0 ? void 0 : _b.call(_a).holdingRegisters)) {
-                        Promise.resolve(this.model.readHoldingRegisters(address, length))
-                            .then((registers) => {
-                            const bufferTx = Buffer.alloc(length * 2);
-                            registers.forEach((register, index) => {
-                                bufferTx.writeUInt16BE(register, index * 2);
-                            });
-                            response(this.applicationLayer.encode(Object.assign(Object.assign({}, frame), { data: [bufferTx.length].concat(Array.from(bufferTx)) })));
-                        })
-                            .catch((error) => {
-                            this.responseError(frame, response, error);
-                        });
-                    }
-                    else {
-                        this.responseError(frame, response, getErrorByCode(ErrorCode.ILLEGAL_DATA_ADDRESS));
-                    }
-                }
-                else {
-                    this.responseError(frame, response, getErrorByCode(ErrorCode.ILLEGAL_DATA_VALUE));
-                }
-            }
-            else {
-                this.responseError(frame, response, getErrorByCode(ErrorCode.ILLEGAL_FUNCTION));
-            }
-        }
-    }
-    handleFC4(frame, response) {
-        var _a, _b;
-        if (frame.data.length === 4) {
-            if (this.model.readInputRegisters) {
-                const bufferRx = Buffer.from(frame.data);
-                const address = bufferRx.readUInt16BE(0);
-                const length = bufferRx.readUInt16BE(2);
-                if (length >= 0x0001 && length <= 0x007d) {
-                    if (checkRange([address, address + length], (_b = (_a = this.model).getAddressRange) === null || _b === void 0 ? void 0 : _b.call(_a).inputRegisters)) {
-                        Promise.resolve(this.model.readInputRegisters(address, length))
-                            .then((registers) => {
-                            const bufferTx = Buffer.alloc(length * 2);
-                            registers.forEach((register, index) => {
-                                bufferTx.writeUInt16BE(register, index * 2);
-                            });
-                            response(this.applicationLayer.encode(Object.assign(Object.assign({}, frame), { data: [bufferTx.length].concat(Array.from(bufferTx)) })));
-                        })
-                            .catch((error) => {
-                            this.responseError(frame, response, error);
-                        });
-                    }
-                    else {
-                        this.responseError(frame, response, getErrorByCode(ErrorCode.ILLEGAL_DATA_ADDRESS));
-                    }
-                }
-                else {
-                    this.responseError(frame, response, getErrorByCode(ErrorCode.ILLEGAL_DATA_VALUE));
-                }
-            }
-            else {
-                this.responseError(frame, response, getErrorByCode(ErrorCode.ILLEGAL_FUNCTION));
-            }
-        }
-    }
-    handleFC5(frame, response) {
-        var _a, _b;
-        if (frame.data.length === 4) {
-            if (this.model.writeSingleCoil) {
-                const bufferRx = Buffer.from(frame.data);
-                const address = bufferRx.readUInt16BE(0);
-                const value = bufferRx.readUInt16BE(2);
-                if (value === 0x0000 || value === 0xff00) {
-                    if (checkRange(address, (_b = (_a = this.model).getAddressRange) === null || _b === void 0 ? void 0 : _b.call(_a).coils)) {
-                        Promise.resolve(this.model.writeSingleCoil(address, value === 0xff00))
-                            .then(() => {
-                            response(this.applicationLayer.encode(frame));
-                        })
-                            .catch((error) => {
-                            this.responseError(frame, response, error);
-                        });
-                    }
-                    else {
-                        this.responseError(frame, response, getErrorByCode(ErrorCode.ILLEGAL_DATA_ADDRESS));
-                    }
-                }
-                else {
-                    this.responseError(frame, response, getErrorByCode(ErrorCode.ILLEGAL_DATA_VALUE));
-                }
-            }
-            else {
-                this.responseError(frame, response, getErrorByCode(ErrorCode.ILLEGAL_FUNCTION));
-            }
-        }
-    }
-    handleFC6(frame, response) {
-        var _a, _b;
-        if (frame.data.length === 4) {
-            if (this.model.writeSingleRegister) {
-                const bufferRx = Buffer.from(frame.data);
-                const address = bufferRx.readUInt16BE(0);
-                const value = bufferRx.readUInt16BE(2);
-                if (value >= 0x0000 && value <= 0xffff) {
-                    if (checkRange(address, (_b = (_a = this.model).getAddressRange) === null || _b === void 0 ? void 0 : _b.call(_a).holdingRegisters)) {
-                        Promise.resolve(this.model.writeSingleRegister(address, value))
-                            .then(() => {
-                            response(this.applicationLayer.encode(frame));
-                        })
-                            .catch((error) => {
-                            this.responseError(frame, response, error);
-                        });
-                    }
-                    else {
-                        this.responseError(frame, response, getErrorByCode(ErrorCode.ILLEGAL_DATA_ADDRESS));
-                    }
-                }
-                else {
-                    this.responseError(frame, response, getErrorByCode(ErrorCode.ILLEGAL_DATA_VALUE));
-                }
-            }
-            else {
-                this.responseError(frame, response, getErrorByCode(ErrorCode.ILLEGAL_FUNCTION));
-            }
-        }
-    }
-    handleFC15(frame, response) {
-        var _a, _b;
-        if (frame.data.length > 5 && frame.data.length === 5 + frame.data[4]) {
-            if (this.model.writeMultipleCoils || this.model.writeSingleCoil) {
-                const bufferRx = Buffer.from(frame.data);
-                const address = bufferRx.readUInt16BE(0);
-                const length = bufferRx.readUInt16BE(2);
-                const byteCount = bufferRx[4];
-                if (length >= 0x0001 && length <= 0x07b0 && byteCount === Math.ceil(length / 8)) {
-                    if (checkRange([address, address + length], (_b = (_a = this.model).getAddressRange) === null || _b === void 0 ? void 0 : _b.call(_a).coils)) {
-                        const value = Array.from({ length }).map((_, index) => (bufferRx[5 + ~~(index / 8)] & (1 << index % 8)) > 0);
-                        Promise.resolve(this.model.writeMultipleCoils
-                            ? this.model.writeMultipleCoils(address, value)
-                            : Promise.all(value.map((v, i) => this.model.writeSingleCoil(address + i, v))))
-                            .then(() => {
-                            response(this.applicationLayer.encode(Object.assign(Object.assign({}, frame), { data: Array.from(bufferRx).slice(0, 4) })));
-                        })
-                            .catch((error) => {
-                            this.responseError(frame, response, error);
-                        });
-                    }
-                    else {
-                        this.responseError(frame, response, getErrorByCode(ErrorCode.ILLEGAL_DATA_ADDRESS));
-                    }
-                }
-                else {
-                    this.responseError(frame, response, getErrorByCode(ErrorCode.ILLEGAL_DATA_VALUE));
-                }
-            }
-            else {
-                this.responseError(frame, response, getErrorByCode(ErrorCode.ILLEGAL_FUNCTION));
-            }
-        }
-    }
-    handleFC16(frame, response) {
-        var _a, _b;
-        if (frame.data.length > 5 && frame.data.length === 5 + frame.data[4]) {
-            if (this.model.writeMultipleRegisters || this.model.writeSingleRegister) {
-                const bufferRx = Buffer.from(frame.data);
-                const address = bufferRx.readUInt16BE(0);
-                const length = bufferRx.readUInt16BE(2);
-                const byteCount = bufferRx[4];
-                if (length >= 0x0001 && length <= 0x007b && byteCount === length * 2) {
-                    if (checkRange([address, address + length], (_b = (_a = this.model).getAddressRange) === null || _b === void 0 ? void 0 : _b.call(_a).holdingRegisters)) {
-                        const value = Array.from({ length }).map((_, index) => bufferRx.readUInt16BE(5 + index * 2));
-                        Promise.resolve(this.model.writeMultipleRegisters
-                            ? this.model.writeMultipleRegisters(address, value)
-                            : Promise.all(value.map((v, i) => this.model.writeSingleRegister(address + i, v))))
-                            .then(() => {
-                            response(this.applicationLayer.encode(Object.assign(Object.assign({}, frame), { data: Array.from(bufferRx).slice(0, 4) })));
-                        })
-                            .catch((error) => {
-                            this.responseError(frame, response, error);
-                        });
-                    }
-                    else {
-                        this.responseError(frame, response, getErrorByCode(ErrorCode.ILLEGAL_DATA_ADDRESS));
-                    }
-                }
-                else {
-                    this.responseError(frame, response, getErrorByCode(ErrorCode.ILLEGAL_DATA_VALUE));
-                }
-            }
-            else {
-                this.responseError(frame, response, getErrorByCode(ErrorCode.ILLEGAL_FUNCTION));
-            }
-        }
-    }
-    handleFC17(frame, response) {
-        if (frame.data.length === 0) {
-            if (this.model.reportServerId) {
-                Promise.resolve(this.model.reportServerId())
-                    .then(({ serverId = this.unit, runIndicatorStatus = true, additionalData = [] }) => {
-                    response(this.applicationLayer.encode(Object.assign(Object.assign({}, frame), { data: [2 + additionalData.length, serverId, runIndicatorStatus ? 0xff : 0x00].concat(additionalData) })));
-                })
-                    .catch((error) => {
-                    this.responseError(frame, response, error);
-                });
-            }
-            else {
-                this.responseError(frame, response, getErrorByCode(ErrorCode.ILLEGAL_FUNCTION));
-            }
-        }
-    }
-    handleFC22(frame, response) {
-        var _a, _b;
-        if (frame.data.length === 6) {
-            if (this.model.maskWriteRegister || (this.model.readHoldingRegisters && this.model.writeSingleRegister)) {
-                const bufferRx = Buffer.from(frame.data);
-                const address = bufferRx.readUInt16BE(0);
-                const andMask = bufferRx.readUInt16BE(2);
-                const orMask = bufferRx.readUInt16BE(4);
-                if (checkRange(address, (_b = (_a = this.model).getAddressRange) === null || _b === void 0 ? void 0 : _b.call(_a).holdingRegisters)) {
-                    Promise.resolve(this.model.maskWriteRegister
-                        ? this.model.maskWriteRegister(address, andMask, orMask)
-                        : Promise.resolve(this.model.readHoldingRegisters(address, 1)).then(([value]) => {
-                            return Promise.resolve(this.model.writeSingleRegister(address, (value & andMask) | (orMask & (~andMask & 0xff))));
-                        }))
-                        .then(() => {
-                        response(this.applicationLayer.encode(frame));
-                    })
-                        .catch((error) => {
-                        this.responseError(frame, response, error);
-                    });
-                }
-                else {
-                    this.responseError(frame, response, getErrorByCode(ErrorCode.ILLEGAL_DATA_ADDRESS));
-                }
-            }
-            else {
-                this.responseError(frame, response, getErrorByCode(ErrorCode.ILLEGAL_FUNCTION));
-            }
-        }
-    }
-    handleFC23(frame, response) {
-        var _a, _b;
-        if (frame.data.length > 9 && frame.data.length === 9 + frame.data[8]) {
-            if (this.model.readHoldingRegisters && (this.model.writeMultipleRegisters || this.model.writeSingleRegister)) {
-                const bufferRx = Buffer.from(frame.data);
-                const address = {
-                    read: bufferRx.readUInt16BE(0),
-                    write: bufferRx.readUInt16BE(4),
-                };
-                const length = {
-                    read: bufferRx.readUInt16BE(2),
-                    write: bufferRx.readUInt16BE(6),
-                };
-                const byteCount = bufferRx[8];
-                if (length.read >= 0x0001 &&
-                    length.read <= 0x007d &&
-                    length.write >= 0x0001 &&
-                    length.write <= 0x0079 &&
-                    byteCount === length.write * 2) {
-                    if (checkRange([address.read, address.read + length.read, address.write, address.write + length.write], (_b = (_a = this.model).getAddressRange) === null || _b === void 0 ? void 0 : _b.call(_a).holdingRegisters)) {
-                        const value = Array.from({ length: length.write }).map((_, index) => bufferRx.readUInt16BE(9 + index * 2));
-                        Promise.resolve(this.model.writeMultipleRegisters
-                            ? this.model.writeMultipleRegisters(address.write, value)
-                            : Promise.all(value.map((v, i) => this.model.writeSingleRegister(address.write + i, v))))
-                            .then(() => Promise.resolve(this.model.readHoldingRegisters(address.read, length.read)))
-                            .then((registers) => {
-                            const bufferTx = Buffer.alloc(length.read * 2);
-                            registers.forEach((register, index) => {
-                                bufferTx.writeUInt16BE(register, index * 2);
-                            });
-                            response(this.applicationLayer.encode(Object.assign(Object.assign({}, frame), { data: [bufferTx.length].concat(Array.from(bufferTx)) })));
-                        })
-                            .catch((error) => {
-                            this.responseError(frame, response, error);
-                        });
-                    }
-                    else {
-                        this.responseError(frame, response, getErrorByCode(ErrorCode.ILLEGAL_DATA_ADDRESS));
-                    }
-                }
-                else {
-                    this.responseError(frame, response, getErrorByCode(ErrorCode.ILLEGAL_DATA_VALUE));
-                }
-            }
-            else {
-                this.responseError(frame, response, getErrorByCode(ErrorCode.ILLEGAL_FUNCTION));
-            }
-        }
-    }
-    handleFC43_14(frame, response) {
-        if (frame.data.length === 3) {
-            if (frame.data[0] === 0x0e && this.model.readDeviceIdentification) {
-                const readDeviceIDCode = frame.data[1];
-                let objectID = frame.data[2];
-                switch (readDeviceIDCode) {
-                    case 0x01: {
-                        if (objectID > 0x02 || (objectID > 0x06 && objectID < 0x80)) {
-                            objectID = 0x00;
-                        }
-                        break;
-                    }
-                    case 0x02: {
-                        if (objectID >= 0x80 || (objectID > 0x06 && objectID < 0x80)) {
-                            objectID = 0x00;
-                        }
-                        break;
-                    }
-                    case 0x03: {
-                        if (objectID > 0x06 && objectID < 0x80) {
-                            objectID = 0x00;
-                        }
-                        break;
-                    }
-                    case 0x04: {
-                        if (objectID > 0x06 && objectID < 0x80) {
-                            this.responseError(frame, response, getErrorByCode(ErrorCode.ILLEGAL_DATA_ADDRESS));
-                            return;
-                        }
-                        break;
-                    }
-                    default: {
-                        this.responseError(frame, response, getErrorByCode(ErrorCode.ILLEGAL_DATA_VALUE));
-                        return;
-                    }
-                }
-                Promise.resolve(this.model.readDeviceIdentification())
-                    .then((identification) => {
-                    const objects = new Map([
-                        [0x00, 'null'],
-                        [0x01, 'null'],
-                        [0x02, 'null'],
-                    ]);
-                    for (const [key, value] of Object.entries(identification)) {
-                        const id = parseInt(key);
-                        if (!isNaN(id) && id >= 0 && id <= 255) {
-                            objects.set(id, value);
-                        }
-                    }
-                    if (!objects.has(objectID)) {
-                        if (readDeviceIDCode === 0x04) {
-                            this.responseError(frame, response, getErrorByCode(ErrorCode.ILLEGAL_DATA_ADDRESS));
-                            return;
-                        }
-                        objectID = 0x00;
-                    }
-                    const ids = [];
-                    let totalLength = 10;
-                    let lastID = 0;
-                    let conformityLevel = 0x81;
-                    for (const [id, value] of objects.entries()) {
-                        if (id < 0x00 || (id >= 0x07 && id <= 0x7f) || id > 0xff) {
-                            this.responseError(frame, response, getErrorByCode(ErrorCode.SERVER_DEVICE_FAILURE));
-                            return;
-                        }
-                        if (id > 0x02) {
-                            conformityLevel = 0x82;
-                        }
-                        if (id > 0x80) {
-                            conformityLevel = 0x83;
-                        }
-                        if (objectID > id) {
-                            continue;
-                        }
-                        if (value.length > 245) {
-                            this.responseError(frame, response, getErrorByCode(ErrorCode.SERVER_DEVICE_FAILURE));
-                            return;
-                        }
-                        if (lastID !== 0) {
-                            continue;
-                        }
-                        if (value.length + 2 > 253 - totalLength) {
-                            if (lastID === 0) {
-                                lastID = id;
-                            }
-                        }
-                        else {
-                            totalLength += value.length + 2;
-                            ids.push(id);
-                            if (readDeviceIDCode === 0x04) {
-                                break;
-                            }
-                        }
-                    }
-                    ids.sort((a, b) => a - b);
-                    response(this.applicationLayer.encode(Object.assign(Object.assign({}, frame), { data: [0x0e, readDeviceIDCode, conformityLevel, lastID === 0 ? 0x00 : 0xff, lastID, ids.length].concat(ids
-                            .map((id) => {
-                            const value = objects.get(id);
-                            return [id, value.length].concat(Array.from(Buffer.from(value)));
-                        })
-                            .flat()) })));
-                })
-                    .catch((error) => {
-                    this.responseError(frame, response, error);
-                });
-            }
-            else {
-                this.responseError(frame, response, getErrorByCode(ErrorCode.ILLEGAL_FUNCTION));
-            }
-        }
-    }
-    responseError(frame, response, error) {
-        response(this.applicationLayer.encode(Object.assign(Object.assign({}, frame), { fc: frame.fc | 0x80, data: [getCodeByError(error)] })));
-    }
-    open(...args) {
-        return this.physicalLayer.open(...args);
-    }
-    close() {
-        return this.physicalLayer.close();
-    }
-    destroy() {
-        this.removeAllListeners();
-        this.applicationLayer.destroy();
-        return this.physicalLayer.destroy();
-    }
-}
-
-export { AbstractApplicationLayer, AbstractPhysicalLayer, AsciiApplicationLayer, ErrorCode, ModbusMaster, ModbusSlave, RtuApplicationLayer, SerialPhysicalLayer, TcpApplicationLayer, TcpClientPhysicalLayer, TcpServerPhysicalLayer, UdpPhysicalLayer, getCodeByError, getErrorByCode };