@tier0/node-red-contrib-opcda-client 1.0.6 → 1.0.7

package/node_modules/bytebuffer/src/types/ints/int16.js

@@ -0,0 +1,167 @@
+//? if (INT16) {
+// types/ints/int16
+
+/**
+ * Writes a 16bit signed integer.
+ * @param {number} value Value to write
+ * @param {number=} offset Offset to write to. Will use and advance {@link ByteBuffer#offset} by `2` if omitted.
+ * @throws {TypeError} If `offset` or `value` is not a valid number
+ * @throws {RangeError} If `offset` is out of bounds
+ * @expose
+ */
+ByteBufferPrototype.writeInt16 = function(value, offset) {
+    //? RELATIVE();
+    if (!this.noAssert) {
+        //? ASSERT_INTEGER('value');
+        //? ASSERT_OFFSET();
+    }
+    //? ENSURE_CAPACITY(2);
+    //? if (NODE || !DATAVIEW) { var dst = NODE ? 'this.buffer' : 'this.view';
+    if (this.littleEndian) {
+        /*?= dst */[offset+1] = (value & 0xFF00) >>> 8;
+        /*?= dst */[offset  ] =  value & 0x00FF;
+    } else {
+        /*?= dst */[offset]   = (value & 0xFF00) >>> 8;
+        /*?= dst */[offset+1] =  value & 0x00FF;
+    }
+    //? } else
+    this.view.setInt16(offset, value, this.littleEndian);
+    //? RELATIVE(2);
+    return this;
+};
+//? if (ALIASES) {
+
+/**
+ * Writes a 16bit signed integer. This is an alias of {@link ByteBuffer#writeInt16}.
+ * @function
+ * @param {number} value Value to write
+ * @param {number=} offset Offset to write to. Will use and advance {@link ByteBuffer#offset} by `2` if omitted.
+ * @throws {TypeError} If `offset` or `value` is not a valid number
+ * @throws {RangeError} If `offset` is out of bounds
+ * @expose
+ */
+ByteBufferPrototype.writeShort = ByteBufferPrototype.writeInt16;
+//? }
+
+/**
+ * Reads a 16bit signed integer.
+ * @param {number=} offset Offset to read from. Will use and advance {@link ByteBuffer#offset} by `2` if omitted.
+ * @returns {number} Value read
+ * @throws {TypeError} If `offset` is not a valid number
+ * @throws {RangeError} If `offset` is out of bounds
+ * @expose
+ */
+ByteBufferPrototype.readInt16 = function(offset) {
+    //? RELATIVE();
+    if (!this.noAssert) {
+        //? ASSERT_OFFSET(2);
+    }
+    //? if (NODE || !DATAVIEW) { var dst = NODE ? 'this.buffer' : 'this.view';
+    var value = 0;
+    if (this.littleEndian) {
+        value  = /*?= dst */[offset  ];
+        value |= /*?= dst */[offset+1] << 8;
+    } else {
+        value  = /*?= dst */[offset  ] << 8;
+        value |= /*?= dst */[offset+1];
+    }
+    if ((value & 0x8000) === 0x8000) value = -(0xFFFF - value + 1); // Cast to signed
+    //? } else
+    var value = this.view.getInt16(offset, this.littleEndian);
+    //? RELATIVE(2);
+    return value;
+};
+//? if (ALIASES) {
+
+/**
+ * Reads a 16bit signed integer. This is an alias of {@link ByteBuffer#readInt16}.
+ * @function
+ * @param {number=} offset Offset to read from. Will use and advance {@link ByteBuffer#offset} by `2` if omitted.
+ * @returns {number} Value read
+ * @throws {TypeError} If `offset` is not a valid number
+ * @throws {RangeError} If `offset` is out of bounds
+ * @expose
+ */
+ByteBufferPrototype.readShort = ByteBufferPrototype.readInt16;
+//? }
+
+/**
+ * Writes a 16bit unsigned integer.
+ * @param {number} value Value to write
+ * @param {number=} offset Offset to write to. Will use and advance {@link ByteBuffer#offset} by `2` if omitted.
+ * @throws {TypeError} If `offset` or `value` is not a valid number
+ * @throws {RangeError} If `offset` is out of bounds
+ * @expose
+ */
+ByteBufferPrototype.writeUint16 = function(value, offset) {
+    //? RELATIVE();
+    if (!this.noAssert) {
+        //? ASSERT_INTEGER('value', true);
+        //? ASSERT_OFFSET();
+    }
+    //? ENSURE_CAPACITY(2);
+    //? if (NODE || !DATAVIEW) { var dst = NODE ? 'this.buffer' : 'this.view';
+    if (this.littleEndian) {
+        /*?= dst */[offset+1] = (value & 0xFF00) >>> 8;
+        /*?= dst */[offset  ] =  value & 0x00FF;
+    } else {
+        /*?= dst */[offset]   = (value & 0xFF00) >>> 8;
+        /*?= dst */[offset+1] =  value & 0x00FF;
+    }
+    //? } else
+    this.view.setUint16(offset, value, this.littleEndian);
+    //? RELATIVE(2);
+    return this;
+};
+
+/**
+ * Writes a 16bit unsigned integer. This is an alias of {@link ByteBuffer#writeUint16}.
+ * @function
+ * @param {number} value Value to write
+ * @param {number=} offset Offset to write to. Will use and advance {@link ByteBuffer#offset} by `2` if omitted.
+ * @throws {TypeError} If `offset` or `value` is not a valid number
+ * @throws {RangeError} If `offset` is out of bounds
+ * @expose
+ */
+ByteBufferPrototype.writeUInt16 = ByteBufferPrototype.writeUint16;
+
+/**
+ * Reads a 16bit unsigned integer.
+ * @param {number=} offset Offset to read from. Will use and advance {@link ByteBuffer#offset} by `2` if omitted.
+ * @returns {number} Value read
+ * @throws {TypeError} If `offset` is not a valid number
+ * @throws {RangeError} If `offset` is out of bounds
+ * @expose
+ */
+ByteBufferPrototype.readUint16 = function(offset) {
+    //? RELATIVE();
+    if (!this.noAssert) {
+        //? ASSERT_OFFSET(2);
+    }
+    //? if (NODE || !DATAVIEW) { var dst = NODE ? 'this.buffer' : 'this.view';
+    var value = 0;
+    if (this.littleEndian) {
+        value  = /*?= dst */[offset  ];
+        value |= /*?= dst */[offset+1] << 8;
+    } else {
+        value  = /*?= dst */[offset  ] << 8;
+        value |= /*?= dst */[offset+1];
+    }
+    //? } else
+    var value = this.view.getUint16(offset, this.littleEndian);
+    //? RELATIVE(2);
+    return value;
+};
+
+/**
+ * Reads a 16bit unsigned integer. This is an alias of {@link ByteBuffer#readUint16}.
+ * @function
+ * @param {number=} offset Offset to read from. Will use and advance {@link ByteBuffer#offset} by `2` if omitted.
+ * @returns {number} Value read
+ * @throws {TypeError} If `offset` is not a valid number
+ * @throws {RangeError} If `offset` is out of bounds
+ * @expose
+ */
+ByteBufferPrototype.readUInt16 = ByteBufferPrototype.readUint16;
+
+//? }

package/node_modules/bytebuffer/src/types/ints/int32.js

@@ -0,0 +1,125 @@
+//? if (INT32) {
+// types/ints/int32
+
+/**
+ * Writes a 32bit signed integer.
+ * @param {number} value Value to write
+ * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by `4` if omitted.
+ * @expose
+ */
+ByteBufferPrototype.writeInt32 = function(value, offset) {
+    //? RELATIVE();
+    if (!this.noAssert) {
+        //? ASSERT_INTEGER('value');
+        //? ASSERT_OFFSET();
+    }
+    //? ENSURE_CAPACITY(4);
+    //? if (NODE || !DATAVIEW) {
+    //? WRITE_UINT32_ARRAY();
+    //? } else
+    this.view.setInt32(offset, value, this.littleEndian);
+    //? RELATIVE(4);
+    return this;
+};
+//? if (ALIASES) {
+
+/**
+ * Writes a 32bit signed integer. This is an alias of {@link ByteBuffer#writeInt32}.
+ * @param {number} value Value to write
+ * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by `4` if omitted.
+ * @expose
+ */
+ByteBufferPrototype.writeInt = ByteBufferPrototype.writeInt32;
+//? }
+
+/**
+ * Reads a 32bit signed integer.
+ * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by `4` if omitted.
+ * @returns {number} Value read
+ * @expose
+ */
+ByteBufferPrototype.readInt32 = function(offset) {
+    //? RELATIVE();
+    if (!this.noAssert) {
+        //? ASSERT_OFFSET(4);
+    }
+    //? if (NODE || !DATAVIEW) {
+    var value = 0;
+    //? READ_UINT32_ARRAY();
+    value |= 0; // Cast to signed
+    //? } else
+    var value = this.view.getInt32(offset, this.littleEndian);
+    //? RELATIVE(4);
+    return value;
+};
+//? if (ALIASES) {
+
+/**
+ * Reads a 32bit signed integer. This is an alias of {@link ByteBuffer#readInt32}.
+ * @param {number=} offset Offset to read from. Will use and advance {@link ByteBuffer#offset} by `4` if omitted.
+ * @returns {number} Value read
+ * @expose
+ */
+ByteBufferPrototype.readInt = ByteBufferPrototype.readInt32;
+//? }
+
+/**
+ * Writes a 32bit unsigned integer.
+ * @param {number} value Value to write
+ * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by `4` if omitted.
+ * @expose
+ */
+ByteBufferPrototype.writeUint32 = function(value, offset) {
+    //? RELATIVE();
+    if (!this.noAssert) {
+        //? ASSERT_INTEGER('value', true);
+        //? ASSERT_OFFSET();
+    }
+    //? ENSURE_CAPACITY(4);
+    //? if (NODE || !DATAVIEW) {
+    //? WRITE_UINT32_ARRAY();
+    //? } else
+    this.view.setUint32(offset, value, this.littleEndian);
+    //? RELATIVE(4);
+    return this;
+};
+
+/**
+ * Writes a 32bit unsigned integer. This is an alias of {@link ByteBuffer#writeUint32}.
+ * @function
+ * @param {number} value Value to write
+ * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by `4` if omitted.
+ * @expose
+ */
+ByteBufferPrototype.writeUInt32 = ByteBufferPrototype.writeUint32;
+
+/**
+ * Reads a 32bit unsigned integer.
+ * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by `4` if omitted.
+ * @returns {number} Value read
+ * @expose
+ */
+ByteBufferPrototype.readUint32 = function(offset) {
+    //? RELATIVE();
+    if (!this.noAssert) {
+        //? ASSERT_OFFSET(4);
+    }
+    //? if (NODE || !DATAVIEW) {
+    var value = 0;
+    //? READ_UINT32_ARRAY();
+    //? } else
+    var value = this.view.getUint32(offset, this.littleEndian);
+    //? RELATIVE(4);
+    return value;
+};
+
+/**
+ * Reads a 32bit unsigned integer. This is an alias of {@link ByteBuffer#readUint32}.
+ * @function
+ * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by `4` if omitted.
+ * @returns {number} Value read
+ * @expose
+ */
+ByteBufferPrototype.readUInt32 = ByteBufferPrototype.readUint32;
+
+//? }

package/node_modules/bytebuffer/src/types/ints/int64.js

@@ -0,0 +1,194 @@
+//? if (INT64) {
+// types/ints/int64
+
+if (Long) {
+
+    /**
+     * Writes a 64bit signed integer.
+     * @param {number|!Long} value Value to write
+     * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by `8` if omitted.
+     * @returns {!ByteBuffer} this
+     * @expose
+     */
+    ByteBufferPrototype.writeInt64 = function(value, offset) {
+        //? RELATIVE();
+        if (!this.noAssert) {
+            //? ASSERT_LONG('value');
+            //? ASSERT_OFFSET();
+        }
+        //? LONG('value');
+        //? ENSURE_CAPACITY(8);
+        //? if (NODE || !DATAVIEW) {
+        var lo = value.low,
+            hi = value.high;
+        if (this.littleEndian) {
+            //? WRITE_UINT32_ARRAY('lo', undefined, undefined, true);
+            offset += 4;
+            //? WRITE_UINT32_ARRAY('hi', undefined, undefined, true);
+        } else {
+            //? WRITE_UINT32_ARRAY('hi', undefined, undefined, false);
+            offset += 4;
+            //? WRITE_UINT32_ARRAY('lo', undefined, undefined, false);
+        }
+        //? } else {
+        if (this.littleEndian) {
+            this.view.setInt32(offset  , value.low , true);
+            this.view.setInt32(offset+4, value.high, true);
+        } else {
+            this.view.setInt32(offset  , value.high, false);
+            this.view.setInt32(offset+4, value.low , false);
+        }
+        //? }
+        //? RELATIVE(8);
+        return this;
+    };
+    //? if (ALIASES) {
+
+    /**
+     * Writes a 64bit signed integer. This is an alias of {@link ByteBuffer#writeInt64}.
+     * @param {number|!Long} value Value to write
+     * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by `8` if omitted.
+     * @returns {!ByteBuffer} this
+     * @expose
+     */
+    ByteBufferPrototype.writeLong = ByteBufferPrototype.writeInt64;
+    //? }
+    
+    /**
+     * Reads a 64bit signed integer.
+     * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by `8` if omitted.
+     * @returns {!Long}
+     * @expose
+     */
+    ByteBufferPrototype.readInt64 = function(offset) {
+        //? RELATIVE();
+        if (!this.noAssert) {
+            //? ASSERT_OFFSET(8);
+        }
+        //? if (NODE || !DATAVIEW) {
+        var lo = 0,
+            hi = 0;
+        if (this.littleEndian) {
+            //? READ_UINT32_ARRAY('lo', undefined, undefined, true);
+            offset += 4;
+            //? READ_UINT32_ARRAY('hi', undefined, undefined, true);
+        } else {
+            //? READ_UINT32_ARRAY('hi', undefined, undefined, false);
+            offset += 4;
+            //? READ_UINT32_ARRAY('lo', undefined, undefined, false);
+        }
+        var value = new Long(lo, hi, false);
+        //? } else {
+        var value = this.littleEndian
+            ? new Long(this.view.getInt32(offset  , true ), this.view.getInt32(offset+4, true ), false)
+            : new Long(this.view.getInt32(offset+4, false), this.view.getInt32(offset  , false), false);
+        //? }
+        //? RELATIVE(8);
+        return value;
+    };
+    //? if (ALIASES) {
+
+    /**
+     * Reads a 64bit signed integer. This is an alias of {@link ByteBuffer#readInt64}.
+     * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by `8` if omitted.
+     * @returns {!Long}
+     * @expose
+     */
+    ByteBufferPrototype.readLong = ByteBufferPrototype.readInt64;
+    //? }
+    
+    /**
+     * Writes a 64bit unsigned integer.
+     * @param {number|!Long} value Value to write
+     * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by `8` if omitted.
+     * @returns {!ByteBuffer} this
+     * @expose
+     */
+    ByteBufferPrototype.writeUint64 = function(value, offset) {
+        //? RELATIVE();
+        if (!this.noAssert) {
+            //? ASSERT_LONG('value');
+            //? ASSERT_OFFSET();
+        }
+        //? LONG('value');
+        //? ENSURE_CAPACITY(8);
+        //? if (NODE || !DATAVIEW) {
+        var lo = value.low,
+            hi = value.high;
+        if (this.littleEndian) {
+            //? WRITE_UINT32_ARRAY('lo', undefined, undefined, true);
+            offset += 4;
+            //? WRITE_UINT32_ARRAY('hi', undefined, undefined, true);
+        } else {
+            //? WRITE_UINT32_ARRAY('hi', undefined, undefined, false);
+            offset += 4;
+            //? WRITE_UINT32_ARRAY('lo', undefined, undefined, false);
+        }
+        //? } else {
+        if (this.littleEndian) {
+            this.view.setInt32(offset  , value.low , true);
+            this.view.setInt32(offset+4, value.high, true);
+        } else {
+            this.view.setInt32(offset  , value.high, false);
+            this.view.setInt32(offset+4, value.low , false);
+        }
+        //? }
+        //? RELATIVE(8);
+        return this;
+    };
+
+    /**
+     * Writes a 64bit unsigned integer. This is an alias of {@link ByteBuffer#writeUint64}.
+     * @function
+     * @param {number|!Long} value Value to write
+     * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by `8` if omitted.
+     * @returns {!ByteBuffer} this
+     * @expose
+     */
+    ByteBufferPrototype.writeUInt64 = ByteBufferPrototype.writeUint64;
+    
+    /**
+     * Reads a 64bit unsigned integer.
+     * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by `8` if omitted.
+     * @returns {!Long}
+     * @expose
+     */
+    ByteBufferPrototype.readUint64 = function(offset) {
+        //? RELATIVE();
+        if (!this.noAssert) {
+            //? ASSERT_OFFSET(8);
+        }
+        //? if (NODE || !DATAVIEW) {
+        var lo = 0,
+            hi = 0;
+        if (this.littleEndian) {
+            //? READ_UINT32_ARRAY('lo', undefined, undefined, true);
+            offset += 4;
+            //? READ_UINT32_ARRAY('hi', undefined, undefined, true);
+        } else {
+            //? READ_UINT32_ARRAY('hi', undefined, undefined, false);
+            offset += 4;
+            //? READ_UINT32_ARRAY('lo', undefined, undefined, false);
+        }
+        var value = new Long(lo, hi, true);
+        //? } else {
+        var value = this.littleEndian
+            ? new Long(this.view.getInt32(offset  , true ), this.view.getInt32(offset+4, true ), true)
+            : new Long(this.view.getInt32(offset+4, false), this.view.getInt32(offset  , false), true);
+        //? }
+        //? RELATIVE(8);
+        return value;
+    };
+
+    /**
+     * Reads a 64bit unsigned integer. This is an alias of {@link ByteBuffer#readUint64}.
+     * @function
+     * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by `8` if omitted.
+     * @returns {!Long}
+     * @expose
+     */
+    ByteBufferPrototype.readUInt64 = ByteBufferPrototype.readUint64;
+    
+} // Long
+
+//? }

package/node_modules/bytebuffer/src/types/ints/int8.js

@@ -0,0 +1,137 @@
+//? if (INT8) {
+// types/ints/int8
+
+/**
+ * Writes an 8bit signed integer.
+ * @param {number} value Value to write
+ * @param {number=} offset Offset to write to. Will use and advance {@link ByteBuffer#offset} by `1` if omitted.
+ * @returns {!ByteBuffer} this
+ * @expose
+ */
+ByteBufferPrototype.writeInt8 = function(value, offset) {
+    //? RELATIVE();
+    if (!this.noAssert) {
+        //? ASSERT_INTEGER('value');
+        //? ASSERT_OFFSET();
+    }
+    //? ENSURE_CAPACITY(1);
+    //? if (NODE)
+    this.buffer[offset] = value;
+    //? else if (DATAVIEW)
+    this.view.setInt8(offset, value);
+    //? else
+    this.view[offset] = value;
+    //? RELATIVE(1);
+    return this;
+};
+
+/**
+ * Writes an 8bit signed integer. This is an alias of {@link ByteBuffer#writeInt8}.
+ * @function
+ * @param {number} value Value to write
+ * @param {number=} offset Offset to write to. Will use and advance {@link ByteBuffer#offset} by `1` if omitted.
+ * @returns {!ByteBuffer} this
+ * @expose
+ */
+ByteBufferPrototype.writeByte = ByteBufferPrototype.writeInt8;
+
+/**
+ * Reads an 8bit signed integer.
+ * @param {number=} offset Offset to read from. Will use and advance {@link ByteBuffer#offset} by `1` if omitted.
+ * @returns {number} Value read
+ * @expose
+ */
+ByteBufferPrototype.readInt8 = function(offset) {
+    //? RELATIVE();
+    if (!this.noAssert) {
+        //? ASSERT_OFFSET(1);
+    }
+    //? if (NODE) {
+    var value = this.buffer[offset];
+    if ((value & 0x80) === 0x80) value = -(0xFF - value + 1); // Cast to signed
+    //? } else if (DATAVIEW) {
+    var value = this.view.getInt8(offset);
+    //? } else {
+    var value = this.view[offset];
+    if ((value & 0x80) === 0x80) value = -(0xFF - value + 1); // Cast to signed
+    //? }
+    //? RELATIVE(1);
+    return value;
+};
+//? if (ALIASES) {
+
+/**
+ * Reads an 8bit signed integer. This is an alias of {@link ByteBuffer#readInt8}.
+ * @function
+ * @param {number=} offset Offset to read from. Will use and advance {@link ByteBuffer#offset} by `1` if omitted.
+ * @returns {number} Value read
+ * @expose
+ */
+ByteBufferPrototype.readByte = ByteBufferPrototype.readInt8;
+//? }
+
+/**
+ * Writes an 8bit unsigned integer.
+ * @param {number} value Value to write
+ * @param {number=} offset Offset to write to. Will use and advance {@link ByteBuffer#offset} by `1` if omitted.
+ * @returns {!ByteBuffer} this
+ * @expose
+ */
+ByteBufferPrototype.writeUint8 = function(value, offset) {
+    //? RELATIVE();
+    if (!this.noAssert) {
+        //? ASSERT_INTEGER('value', true);
+        //? ASSERT_OFFSET();
+    }
+    //? ENSURE_CAPACITY(1);
+    //? if (NODE)
+    this.buffer[offset] = value;
+    //? else if (DATAVIEW)
+    this.view.setUint8(offset, value);
+    //? else
+    this.view[offset] = value;
+    //? RELATIVE(1);
+    return this;
+};
+
+/**
+ * Writes an 8bit unsigned integer. This is an alias of {@link ByteBuffer#writeUint8}.
+ * @function
+ * @param {number} value Value to write
+ * @param {number=} offset Offset to write to. Will use and advance {@link ByteBuffer#offset} by `1` if omitted.
+ * @returns {!ByteBuffer} this
+ * @expose
+ */
+ByteBufferPrototype.writeUInt8 = ByteBufferPrototype.writeUint8;
+
+/**
+ * Reads an 8bit unsigned integer.
+ * @param {number=} offset Offset to read from. Will use and advance {@link ByteBuffer#offset} by `1` if omitted.
+ * @returns {number} Value read
+ * @expose
+ */
+ByteBufferPrototype.readUint8 = function(offset) {
+    //? RELATIVE();
+    if (!this.noAssert) {
+        //? ASSERT_OFFSET(1);
+    }
+    //? if (NODE)
+    var value = this.buffer[offset];
+    //? else if (DATAVIEW)
+    var value = this.view.getUint8(offset);
+    //? else
+    var value = this.view[offset];
+    //? RELATIVE(1);
+    return value;
+};
+
+/**
+ * Reads an 8bit unsigned integer. This is an alias of {@link ByteBuffer#readUint8}.
+ * @function
+ * @param {number=} offset Offset to read from. Will use and advance {@link ByteBuffer#offset} by `1` if omitted.
+ * @returns {number} Value read
+ * @expose
+ */
+ByteBufferPrototype.readUInt8 = ByteBufferPrototype.readUint8;
+
+//? }