njs-modbus 3.3.0 → 4.0.0

package/dist/utils.cjs

@@ -1,536 +0,0 @@
-'use strict';
-
-/**
- * Convert a number of bits to milliseconds at a given baud rate.
- *
- * Used to derive Modbus RTU timing intervals from bit counts — e.g. 38.5 bits
- * = 3.5 character times at 11 bits/char (t3.5 inter-frame silence), or 16.5
- * bits = 1.5 character times (t1.5 inter-character timeout), per Modbus V1.02
- * §2.5.1.1.
- *
- * @param baudRate Serial port baud rate.
- * @param bits Number of bits to convert.
- * @returns Duration in milliseconds.
- */
-function bitsToMs(baudRate, bits) {
-    return (bits * 1000) / baudRate;
-}
-
-/**
- * Drain a pending-callback array: invoke each callback with the given error (or null).
- *
- * Handles `null`/`undefined` entries (from optional `cb?` parameters) gracefully.
- * Used by physical layers and connections to resolve queued
- * open / close / destroy callbacks.
- */
-function drainCbs(cbs, err) {
-    if (!cbs) {
-        return;
-    }
-    for (const cb of cbs) {
-        cb?.(err);
-    }
-}
-
-function checkRange(value, range) {
-    if (!range || range.length === 0) {
-        return true;
-    }
-    const isMultiRange = Array.isArray(range[0]);
-    const isValueArray = Array.isArray(value);
-    if (!isValueArray && !isMultiRange) {
-        const r = range;
-        const min = r[0], max = r[1];
-        const v = value;
-        return min <= max ? v >= min && v <= max : v >= max && v <= min;
-    }
-    if (!isValueArray && isMultiRange) {
-        const ranges = range;
-        const v = value;
-        for (let i = 0; i < ranges.length; i++) {
-            const min = ranges[i][0], max = ranges[i][1];
-            const lo = min <= max ? min : max;
-            const hi = min <= max ? max : min;
-            if (v >= lo && v <= hi) {
-                return true;
-            }
-        }
-        return false;
-    }
-    const values = value;
-    if (values.length === 0) {
-        return true;
-    }
-    if (!isMultiRange) {
-        const r = range;
-        const min = r[0], max = r[1];
-        const lo = min <= max ? min : max;
-        const hi = min <= max ? max : min;
-        for (let i = 0; i < values.length; i++) {
-            if (values[i] < lo || values[i] > hi) {
-                return false;
-            }
-        }
-        return true;
-    }
-    const ranges = range;
-    for (let i = 0; i < ranges.length; i++) {
-        const min = ranges[i][0], max = ranges[i][1];
-        const lo = min <= max ? min : max;
-        const hi = min <= max ? max : min;
-        let allInRange = true;
-        for (let j = 0; j < values.length; j++) {
-            if (values[j] < lo || values[j] > hi) {
-                allInRange = false;
-                break;
-            }
-        }
-        if (allInRange) {
-            return true;
-        }
-    }
-    return false;
-}
-
-const TABLE = new Uint16Array([
-    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, start, end) {
-    let crc = 0xffff;
-    for (let index = start; index < end; index++) {
-        crc = TABLE[(crc ^ data[index]) & 0xff] ^ (crc >> 8);
-    }
-    return crc;
-}
-
-/**
- * Returns true when `n` is an integer in the unsigned-byte range [0, 255].
- *
- * Used for byte-level Modbus payload validation (function-code values, raw
- * byte arrays in FC17/FC43 responses) — rejects negative, fractional, NaN,
- * Infinity, and out-of-range values uniformly.
- */
-function isUint8(n) {
-    return (n & 0xff) === n;
-}
-
-function lrc(data, start, end) {
-    let sum = 0;
-    for (let i = start; i < end; i++) {
-        sum += data[i];
-    }
-    return -sum & 0xff;
-}
-
-/**
- * Standard Modbus function codes (V1.1b3 §6).
- */
-var FunctionCode;
-(function (FunctionCode) {
-    FunctionCode[FunctionCode["READ_COILS"] = 1] = "READ_COILS";
-    FunctionCode[FunctionCode["READ_DISCRETE_INPUTS"] = 2] = "READ_DISCRETE_INPUTS";
-    FunctionCode[FunctionCode["READ_HOLDING_REGISTERS"] = 3] = "READ_HOLDING_REGISTERS";
-    FunctionCode[FunctionCode["READ_INPUT_REGISTERS"] = 4] = "READ_INPUT_REGISTERS";
-    FunctionCode[FunctionCode["WRITE_SINGLE_COIL"] = 5] = "WRITE_SINGLE_COIL";
-    FunctionCode[FunctionCode["WRITE_SINGLE_REGISTER"] = 6] = "WRITE_SINGLE_REGISTER";
-    FunctionCode[FunctionCode["WRITE_MULTIPLE_COILS"] = 15] = "WRITE_MULTIPLE_COILS";
-    FunctionCode[FunctionCode["WRITE_MULTIPLE_REGISTERS"] = 16] = "WRITE_MULTIPLE_REGISTERS";
-    FunctionCode[FunctionCode["REPORT_SERVER_ID"] = 17] = "REPORT_SERVER_ID";
-    FunctionCode[FunctionCode["MASK_WRITE_REGISTER"] = 22] = "MASK_WRITE_REGISTER";
-    FunctionCode[FunctionCode["READ_WRITE_MULTIPLE_REGISTERS"] = 23] = "READ_WRITE_MULTIPLE_REGISTERS";
-    FunctionCode[FunctionCode["READ_DEVICE_IDENTIFICATION"] = 43] = "READ_DEVICE_IDENTIFICATION";
-})(FunctionCode || (FunctionCode = {}));
-/** Exception response FC = request FC | EXCEPTION_OFFSET (V1.1b3 §7). */
-const EXCEPTION_OFFSET = 0x80;
-/** FC 0x2B MEI sub-function selecting Read Device Identification (V1.1b3 §6.21). */
-const MEI_READ_DEVICE_ID = 0x0e;
-/** Read Device ID code values inside an FC 0x2B / MEI 0x0E request. */
-var ReadDeviceIDCode;
-(function (ReadDeviceIDCode) {
-    ReadDeviceIDCode[ReadDeviceIDCode["BASIC_STREAM"] = 1] = "BASIC_STREAM";
-    ReadDeviceIDCode[ReadDeviceIDCode["REGULAR_STREAM"] = 2] = "REGULAR_STREAM";
-    ReadDeviceIDCode[ReadDeviceIDCode["EXTENDED_STREAM"] = 3] = "EXTENDED_STREAM";
-    ReadDeviceIDCode[ReadDeviceIDCode["SPECIFIC_ACCESS"] = 4] = "SPECIFIC_ACCESS";
-})(ReadDeviceIDCode || (ReadDeviceIDCode = {}));
-/** Conformity level reported in an FC 0x2B / MEI 0x0E response. */
-var ConformityLevel;
-(function (ConformityLevel) {
-    ConformityLevel[ConformityLevel["BASIC"] = 129] = "BASIC";
-    ConformityLevel[ConformityLevel["REGULAR"] = 130] = "REGULAR";
-    ConformityLevel[ConformityLevel["EXTENDED"] = 131] = "EXTENDED";
-})(ConformityLevel || (ConformityLevel = {}));
-/** Shared empty Buffer to avoid repeated allocations. */
-Buffer.alloc(0);
-
-const PREDICT_NEED_MORE = 0;
-const PREDICT_UNKNOWN = -1;
-const REQ_TABLE = new Int32Array(256);
-const RES_TABLE = new Int32Array(256);
-(function initTables() {
-    REQ_TABLE[FunctionCode.READ_COILS] = 8;
-    REQ_TABLE[FunctionCode.READ_DISCRETE_INPUTS] = 8;
-    REQ_TABLE[FunctionCode.READ_HOLDING_REGISTERS] = 8;
-    REQ_TABLE[FunctionCode.READ_INPUT_REGISTERS] = 8;
-    REQ_TABLE[FunctionCode.WRITE_SINGLE_COIL] = 8;
-    REQ_TABLE[FunctionCode.WRITE_SINGLE_REGISTER] = 8;
-    REQ_TABLE[FunctionCode.REPORT_SERVER_ID] = 4;
-    REQ_TABLE[FunctionCode.MASK_WRITE_REGISTER] = 10;
-    REQ_TABLE[FunctionCode.READ_DEVICE_IDENTIFICATION] = 7;
-    REQ_TABLE[FunctionCode.WRITE_MULTIPLE_COILS] = -1545;
-    REQ_TABLE[FunctionCode.WRITE_MULTIPLE_REGISTERS] = -1545;
-    REQ_TABLE[FunctionCode.READ_WRITE_MULTIPLE_REGISTERS] = -2573;
-    RES_TABLE[FunctionCode.WRITE_SINGLE_COIL] = 8;
-    RES_TABLE[FunctionCode.WRITE_SINGLE_REGISTER] = 8;
-    RES_TABLE[FunctionCode.WRITE_MULTIPLE_COILS] = 8;
-    RES_TABLE[FunctionCode.WRITE_MULTIPLE_REGISTERS] = 8;
-    RES_TABLE[FunctionCode.MASK_WRITE_REGISTER] = 10;
-    RES_TABLE[FunctionCode.READ_COILS] = -517;
-    RES_TABLE[FunctionCode.READ_DISCRETE_INPUTS] = -517;
-    RES_TABLE[FunctionCode.READ_HOLDING_REGISTERS] = -517;
-    RES_TABLE[FunctionCode.READ_INPUT_REGISTERS] = -517;
-    RES_TABLE[FunctionCode.REPORT_SERVER_ID] = -517;
-    RES_TABLE[FunctionCode.READ_WRITE_MULTIPLE_REGISTERS] = -517;
-    RES_TABLE[FunctionCode.READ_DEVICE_IDENTIFICATION] = -999;
-})();
-function predictRtuFrameLength(buffer, start, end, isResponse) {
-    const len = end - start;
-    if (len < 2) {
-        return PREDICT_NEED_MORE;
-    }
-    const fc = buffer[start + 1];
-    if (isResponse) {
-        if ((fc & EXCEPTION_OFFSET) !== 0) {
-            return 5;
-        }
-        const val = RES_TABLE[fc];
-        if (val > 0) {
-            return val;
-        }
-        if (val < 0) {
-            if (val === -999) {
-                // FC 43 / MEI 14 response — inline to avoid function-call overhead on
-                // the framing hot path (even though this FC is uncommon).
-                if (end - start < 8) {
-                    return PREDICT_NEED_MORE;
-                }
-                if (buffer[start + 2] !== MEI_READ_DEVICE_ID) {
-                    return PREDICT_UNKNOWN;
-                }
-                const numObjs = buffer[start + 7];
-                let cursor = start + 8;
-                for (let i = 0; i < numObjs; i++) {
-                    if (end < cursor + 2) {
-                        return PREDICT_NEED_MORE;
-                    }
-                    cursor += 2 + buffer[cursor + 1];
-                }
-                return cursor - start + 2;
-            }
-            const decode = -val;
-            const offset = decode >> 8;
-            if (len <= offset) {
-                return PREDICT_NEED_MORE;
-            }
-            return (decode & 0xff) + buffer[start + offset];
-        }
-    }
-    else {
-        const val = REQ_TABLE[fc];
-        if (val > 0) {
-            return val;
-        }
-        if (val < 0) {
-            const decode = -val;
-            const offset = decode >> 8;
-            if (len <= offset) {
-                return PREDICT_NEED_MORE;
-            }
-            return (decode & 0xff) + buffer[start + offset];
-        }
-    }
-    return PREDICT_UNKNOWN;
-}
-
-/**
- * Convert a callback-style `(cb: (err?) => void) => void` call into a Promise.
- */
-function promisifyCb(fn) {
-    return new Promise((resolve, reject) => {
-        fn((err) => {
-            if (err) {
-                reject(err);
-            }
-            else {
-                resolve();
-            }
-        });
-    });
-}
-
-/**
- * Resolve a single RTU timing parameter to milliseconds.
- *
- * Returns `undefined` when the caller did not supply the parameter at all
- * (so the caller knows to fall back to a spec default). An explicit `0` or
- * `{ value: 0 }` returns `0` — the parameter is set, just disabled.
- */
-function resolveOne(value, baudRate, fastBaudMs) {
-    if (value === undefined) {
-        return undefined;
-    }
-    if (typeof value === 'number') {
-        return value;
-    }
-    if (value.unit === 'ms') {
-        return value.value;
-    }
-    // unit === 'bit' — needs baudRate to convert
-    if (baudRate === undefined) {
-        return undefined;
-    }
-    return baudRate > 19200 ? fastBaudMs : Math.ceil(bitsToMs(baudRate, value.value));
-}
-/**
- * Resolve Modbus RTU timing parameters from user options into milliseconds.
- *
- * - `intervalBetweenFrames` (t3.5): if omitted and `baudRate` is present,
- *   defaults to 38.5 bits per Modbus V1.02 §2.5.1.1. Pass `0` to disable.
- * - `interCharTimeout` (t1.5): opt-in; only resolved when explicitly provided.
- *
- * Per the spec, at baud rates > 19200 fixed values are used
- * (1.75 ms for t3.5, 0.75 ms for t1.5) regardless of the bit value.
- */
-function resolveRtuTiming(opts = {}, baudRate) {
-    let intervalBetweenFrames = resolveOne(opts.intervalBetweenFrames, baudRate, 1.75);
-    if (intervalBetweenFrames === undefined) {
-        // Spec default: t3.5 derived from baudRate, or 0 when neither option nor
-        // baudRate were supplied.
-        intervalBetweenFrames = baudRate !== undefined ? (baudRate > 19200 ? 1.75 : Math.ceil(bitsToMs(baudRate, 38.5))) : 0;
-    }
-    let interCharTimeout = resolveOne(opts.interCharTimeout, baudRate, 0.75);
-    if (interCharTimeout === undefined) {
-        // t1.5 is opt-in — no spec-default fallback.
-        interCharTimeout = 0;
-    }
-    return { intervalBetweenFrames, interCharTimeout };
-}
-
-/**
- * Hybrid timer manager: uses native `setTimeout` for low concurrency
- * and switches to a binary min-heap when concurrency exceeds the threshold.
- *
- * Benchmarks (add + clear throughput, Node 24, x64):
- *   1 concurrent:  setTimeout ~1.7× faster than heap
- *   2 concurrent:  setTimeout ~1.6× faster than heap
- *   5 concurrent:  setTimeout ~1.5-1.9× faster than heap
- *  10 concurrent:  roughly equal
- *  20 concurrent:  heap ~1.3× faster than setTimeout[]
- *  50 concurrent:  heap ~1.4-1.7× faster than setTimeout[]
- *
- * The crossover point is around 10 concurrent timers, so the default
- * `concurrentThreshold = 2` keeps the common 1-2 request case on the
- * fast direct path while delegating to the heap for larger batches.
- */
-class TimerHeap {
-    _deadlines = [];
-    _ids = [];
-    _seqs = [];
-    _counter = 0;
-    _timer = null;
-    _onFire;
-    _boundTick;
-    _threshold;
-    _mode = 'direct';
-    _directTimers = new Map();
-    /**
-     * @param onFire  Callback invoked with the timer id when it expires.
-     * @param concurrentThreshold  Maximum number of timers kept as individual
-     *     native `setTimeout` handles. Once exceeded, all timers migrate to
-     *     the internal heap and share a single native timer. Default is 2.
-     */
-    constructor(onFire, concurrentThreshold = 2) {
-        this._onFire = onFire;
-        this._boundTick = this._onTick.bind(this);
-        this._threshold = concurrentThreshold;
-    }
-    get size() {
-        return this._mode === 'direct' ? this._directTimers.size : this._deadlines.length;
-    }
-    add(id, ms) {
-        if (this._mode === 'direct' && this._directTimers.size + 1 <= this._threshold) {
-            const deadline = performance.now() + ms;
-            const handle = setTimeout(() => {
-                if (this._mode !== 'direct') {
-                    return;
-                }
-                this._directTimers.delete(id);
-                this._onFire(id);
-            }, ms);
-            this._directTimers.set(id, { handle, deadline });
-            return;
-        }
-        if (this._mode === 'direct') {
-            this._mode = 'heap';
-            for (const [existingId, { handle, deadline }] of this._directTimers) {
-                clearTimeout(handle);
-                const remaining = Math.max(0, Math.ceil(deadline - performance.now()));
-                if (remaining === 0) {
-                    this._onFire(existingId);
-                }
-                else {
-                    this._heapAdd(existingId, remaining);
-                }
-            }
-            this._directTimers.clear();
-        }
-        this._heapAdd(id, ms);
-    }
-    clear() {
-        for (const { handle } of this._directTimers.values()) {
-            clearTimeout(handle);
-        }
-        this._directTimers.clear();
-        this._mode = 'direct';
-        if (this._timer) {
-            clearTimeout(this._timer);
-            this._timer = null;
-        }
-        this._deadlines.length = 0;
-        this._ids.length = 0;
-        this._seqs.length = 0;
-        this._counter = 0;
-    }
-    _heapAdd(id, ms) {
-        const deadline = performance.now() + ms;
-        const seq = this._counter++;
-        let i = this._deadlines.length;
-        this._deadlines.push(deadline);
-        this._ids.push(id);
-        this._seqs.push(seq);
-        while (i > 0) {
-            const p = (i - 1) >> 1;
-            const parentComesFirst = this._deadlines[p] < deadline || (this._deadlines[p] === deadline && this._seqs[p] < seq);
-            if (parentComesFirst) {
-                break;
-            }
-            this._deadlines[i] = this._deadlines[p];
-            this._ids[i] = this._ids[p];
-            this._seqs[i] = this._seqs[p];
-            i = p;
-        }
-        this._deadlines[i] = deadline;
-        this._ids[i] = id;
-        this._seqs[i] = seq;
-        if (i === 0) {
-            this._refresh();
-        }
-    }
-    _refresh() {
-        if (this._timer) {
-            clearTimeout(this._timer);
-            this._timer = null;
-        }
-        if (this._deadlines.length === 0) {
-            return;
-        }
-        const delay = Math.max(0, Math.ceil(this._deadlines[0] - performance.now()));
-        const safeDelay = Math.min(delay, 2147483647);
-        this._timer = setTimeout(this._boundTick, safeDelay);
-    }
-    _onTick() {
-        this._timer = null;
-        const now = performance.now();
-        try {
-            while (this._deadlines.length > 0 && this._deadlines[0] <= now) {
-                const id = this._pop();
-                this._onFire(id);
-            }
-        }
-        finally {
-            this._refresh();
-        }
-    }
-    _pop() {
-        const topId = this._ids[0];
-        const lastId = this._ids.pop();
-        const lastDeadline = this._deadlines.pop();
-        const lastSeq = this._seqs.pop();
-        const n = this._deadlines.length;
-        if (n > 0) {
-            let i = 0;
-            const half = n >> 1;
-            while (i < half) {
-                let minChild = (i << 1) + 1;
-                const rightChild = minChild + 1;
-                if (rightChild < n) {
-                    const rightComesFirst = this._deadlines[rightChild] < this._deadlines[minChild] ||
-                        (this._deadlines[rightChild] === this._deadlines[minChild] && this._seqs[rightChild] < this._seqs[minChild]);
-                    if (rightComesFirst) {
-                        minChild = rightChild;
-                    }
-                }
-                const lastComesFirst = lastDeadline < this._deadlines[minChild] || (lastDeadline === this._deadlines[minChild] && lastSeq < this._seqs[minChild]);
-                if (lastComesFirst) {
-                    break;
-                }
-                this._deadlines[i] = this._deadlines[minChild];
-                this._ids[i] = this._ids[minChild];
-                this._seqs[i] = this._seqs[minChild];
-                i = minChild;
-            }
-            this._deadlines[i] = lastDeadline;
-            this._ids[i] = lastId;
-            this._seqs[i] = lastSeq;
-        }
-        return topId;
-    }
-}
-
-/**
- * Normalize an IP address by stripping the IPv4-mapped IPv6 prefix.
- * This ensures consistent comparison of addresses like `::ffff:192.168.1.1`.
- */
-function normalizeAddress(address = '') {
-    return address.replace(/^::ffff:/, '');
-}
-/**
- * Check whether a remote address is allowed by the given whitelist.
- * IPv4-mapped IPv6 addresses are normalized before comparison.
- * Returns `true` when whitelist is absent or empty.
- */
-function isWhitelisted(address, whitelist) {
-    if (!whitelist || whitelist.length === 0) {
-        return true;
-    }
-    const normalized = normalizeAddress(address);
-    return whitelist.includes(normalized);
-}
-
-exports.PREDICT_NEED_MORE = PREDICT_NEED_MORE;
-exports.PREDICT_UNKNOWN = PREDICT_UNKNOWN;
-exports.TimerHeap = TimerHeap;
-exports.bitsToMs = bitsToMs;
-exports.checkRange = checkRange;
-exports.crc = crc;
-exports.drainCbs = drainCbs;
-exports.isUint8 = isUint8;
-exports.isWhitelisted = isWhitelisted;
-exports.lrc = lrc;
-exports.predictRtuFrameLength = predictRtuFrameLength;
-exports.promisifyCb = promisifyCb;
-exports.resolveRtuTiming = resolveRtuTiming;

package/dist/utils.d.ts

@@ -1,163 +0,0 @@
-/**
- * RTU timing parameter — accepts either:
- * - a bare `number` in milliseconds (`0` to disable the timer entirely)
- * - `{ unit: 'ms', value: N }` — explicit milliseconds (equivalent to bare `N`)
- * - `{ unit: 'bit', value: N }` — bit-time approximation, derived from `baudRate`
- *
- * The bare-number form is the recommended default; the object form exists for
- * specs that quote bit-time. Pass `0` (or `{ unit: 'ms', value: 0 }`) to disable
- * the timer; either form short-circuits the baudRate-derived fallback.
- */
-type RtuTimingValue = number | {
-    unit: 'bit' | 'ms';
-    value: number;
-};
-/** User-facing RTU protocol options (supports both bit and ms units). */
-interface RtuProtocolOptions {
-    /**
-     * Inter-frame silence (Modbus RTU t3.5).
-     *
-     * - `20` or `{ unit: 'ms', value: 20 }` — 20 ms
-     * - `{ unit: 'bit', value: 38.5 }` — spec bit-time approximation (default when `baudRate` is provided)
-     * - `0` — disable t3.5 timing (immediate parse on every chunk; useful for
-     *   lossless transports such as RTU-over-TCP or PTY-based tests where the
-     *   wire's silence semantics do not apply)
-     *
-     * Per Modbus V1.02 §2.5.1.1, at baud rates > 19200 a fixed 1.75 ms is used
-     * regardless of the bit value.
-     */
-    intervalBetweenFrames?: RtuTimingValue;
-    /**
-     * Inter-character timeout (Modbus RTU t1.5). Opt-in; **disabled** by default.
-     *
-     * - `1` or `{ unit: 'ms', value: 1 }` — 1 ms
-     * - `{ unit: 'bit', value: 21 }` — bit-time approximation (~1.5 char times)
-     * - `0` — disable explicitly
-     *
-     * Per Modbus V1.02 §2.5.1.1, at baud rates > 19200 a fixed 0.75 ms is used
-     * regardless of the bit value.
-     */
-    interCharTimeout?: RtuTimingValue;
-    /**
-     * Buffer pool size per connection (bytes). Defaults to `MAX_FRAME_LENGTH * 2`
-     * (512 bytes). Increase this if you expect frames larger than 256 bytes or
-     * heavy pipelining on a single connection.
-     */
-    poolSize?: number;
-}
-/** Resolved RTU timing values in milliseconds. */
-interface ResolvedRtuTiming {
-    intervalBetweenFrames: number;
-    interCharTimeout: number;
-}
-/**
- * Resolve Modbus RTU timing parameters from user options into milliseconds.
- *
- * - `intervalBetweenFrames` (t3.5): if omitted and `baudRate` is present,
- *   defaults to 38.5 bits per Modbus V1.02 §2.5.1.1. Pass `0` to disable.
- * - `interCharTimeout` (t1.5): opt-in; only resolved when explicitly provided.
- *
- * Per the spec, at baud rates > 19200 fixed values are used
- * (1.75 ms for t3.5, 0.75 ms for t1.5) regardless of the bit value.
- */
-declare function resolveRtuTiming(opts?: RtuProtocolOptions, baudRate?: number): ResolvedRtuTiming;
-
-/**
- * Convert a number of bits to milliseconds at a given baud rate.
- *
- * Used to derive Modbus RTU timing intervals from bit counts — e.g. 38.5 bits
- * = 3.5 character times at 11 bits/char (t3.5 inter-frame silence), or 16.5
- * bits = 1.5 character times (t1.5 inter-character timeout), per Modbus V1.02
- * §2.5.1.1.
- *
- * @param baudRate Serial port baud rate.
- * @param bits Number of bits to convert.
- * @returns Duration in milliseconds.
- */
-declare function bitsToMs(baudRate: number, bits: number): number;
-
-/**
- * Drain a pending-callback array: invoke each callback with the given error (or null).
- *
- * Handles `null`/`undefined` entries (from optional `cb?` parameters) gracefully.
- * Used by physical layers and connections to resolve queued
- * open / close / destroy callbacks.
- */
-declare function drainCbs(cbs: (((err?: Error | null) => void) | undefined)[] | null, err?: Error | null): void;
-
-declare function checkRange(value: number | number[], range?: [number, number] | [number, number][]): boolean;
-
-declare function crc(data: Uint8Array, start: number, end: number): number;
-
-/**
- * Returns true when `n` is an integer in the unsigned-byte range [0, 255].
- *
- * Used for byte-level Modbus payload validation (function-code values, raw
- * byte arrays in FC17/FC43 responses) — rejects negative, fractional, NaN,
- * Infinity, and out-of-range values uniformly.
- */
-declare function isUint8(n: number): boolean;
-
-declare function lrc(data: Uint8Array, start: number, end: number): number;
-
-declare const PREDICT_NEED_MORE = 0;
-declare const PREDICT_UNKNOWN = -1;
-declare function predictRtuFrameLength(buffer: Buffer, start: number, end: number, isResponse: boolean): number;
-
-/**
- * Convert a callback-style `(cb: (err?) => void) => void` call into a Promise.
- */
-declare function promisifyCb(fn: (cb: (err?: Error | null) => void) => void): Promise<void>;
-
-/**
- * Hybrid timer manager: uses native `setTimeout` for low concurrency
- * and switches to a binary min-heap when concurrency exceeds the threshold.
- *
- * Benchmarks (add + clear throughput, Node 24, x64):
- *   1 concurrent:  setTimeout ~1.7× faster than heap
- *   2 concurrent:  setTimeout ~1.6× faster than heap
- *   5 concurrent:  setTimeout ~1.5-1.9× faster than heap
- *  10 concurrent:  roughly equal
- *  20 concurrent:  heap ~1.3× faster than setTimeout[]
- *  50 concurrent:  heap ~1.4-1.7× faster than setTimeout[]
- *
- * The crossover point is around 10 concurrent timers, so the default
- * `concurrentThreshold = 2` keeps the common 1-2 request case on the
- * fast direct path while delegating to the heap for larger batches.
- */
-declare class TimerHeap {
-    private _deadlines;
-    private _ids;
-    private _seqs;
-    private _counter;
-    private _timer;
-    private _onFire;
-    private _boundTick;
-    private _threshold;
-    private _mode;
-    private _directTimers;
-    /**
-     * @param onFire  Callback invoked with the timer id when it expires.
-     * @param concurrentThreshold  Maximum number of timers kept as individual
-     *     native `setTimeout` handles. Once exceeded, all timers migrate to
-     *     the internal heap and share a single native timer. Default is 2.
-     */
-    constructor(onFire: (id: number) => void, concurrentThreshold?: number);
-    get size(): number;
-    add(id: number, ms: number): void;
-    clear(): void;
-    private _heapAdd;
-    private _refresh;
-    private _onTick;
-    private _pop;
-}
-
-/**
- * Check whether a remote address is allowed by the given whitelist.
- * IPv4-mapped IPv6 addresses are normalized before comparison.
- * Returns `true` when whitelist is absent or empty.
- */
-declare function isWhitelisted(address: string | undefined, whitelist: string[] | undefined): boolean;
-
-export { PREDICT_NEED_MORE, PREDICT_UNKNOWN, TimerHeap, bitsToMs, checkRange, crc, drainCbs, isUint8, isWhitelisted, lrc, predictRtuFrameLength, promisifyCb, resolveRtuTiming };
-export type { ResolvedRtuTiming, RtuProtocolOptions };