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

package/node_modules/bytebuffer/src/methods/toBuffer.js

@@ -0,0 +1,77 @@
+/**
+ * Returns a copy of the backing buffer that contains this ByteBuffer's contents. Contents are the bytes between
+ *  {@link ByteBuffer#offset} and {@link ByteBuffer#limit}.
+ * @param {boolean=} forceCopy If `true` returns a copy, otherwise returns a view referencing the same memory if
+ *  possible. Defaults to `false`
+//? if (NODE) {
+ * @returns {!Buffer} Contents as a Buffer
+//? } else {
+ * @returns {!ArrayBuffer} Contents as an ArrayBuffer
+//? }
+ * @expose
+ */
+ByteBufferPrototype.toBuffer = function(forceCopy) {
+    var offset = this.offset,
+        limit = this.limit;
+    if (!this.noAssert) {
+        //? ASSERT_RANGE('offset', 'limit');
+    }
+    //? if (NODE) {
+    if (forceCopy) {
+        var buffer = new Buffer(limit - offset);
+        this.buffer.copy(buffer, 0, offset, limit);
+        return buffer;
+    } else {
+        if (offset === 0 && limit === this.buffer.length)
+            return this.buffer;
+        else
+            return this.buffer.slice(offset, limit);
+    }
+    //? } else {
+    // NOTE: It's not possible to have another ArrayBuffer reference the same memory as the backing buffer. This is
+    // possible with Uint8Array#subarray only, but we have to return an ArrayBuffer by contract. So:
+    if (!forceCopy && offset === 0 && limit === this.buffer.byteLength)
+        return this.buffer;
+    if (offset === limit)
+        return EMPTY_BUFFER;
+    var buffer = new ArrayBuffer(limit - offset);
+    new Uint8Array(buffer).set(new Uint8Array(this.buffer).subarray(offset, limit), 0);
+    return buffer;
+    //? }
+};
+
+//? if (NODE) {
+/**
+ * Returns a copy of the backing buffer compacted to contain this ByteBuffer's contents. Contents are the bytes between
+ *  {@link ByteBuffer#offset} and {@link ByteBuffer#limit}.
+ * @returns {!ArrayBuffer} Contents as an ArrayBuffer
+ */
+ByteBufferPrototype.toArrayBuffer = function() {
+    var offset = this.offset,
+        limit = this.limit;
+    if (!this.noAssert) {
+        //? ASSERT_RANGE('offset', 'limit');
+    }
+    var ab = new ArrayBuffer(limit - offset);
+    if (memcpy) { // Fast
+        memcpy(ab, 0, this.buffer, offset, limit);
+    } else { // Slow
+        var dst = new Uint8Array(ab);
+        for (var i=offset; i<limit; ++i)
+            dst[i-offset] = this.buffer[i];
+    }
+    return ab;
+};
+//? } else {
+/**
+ * Returns a raw buffer compacted to contain this ByteBuffer's contents. Contents are the bytes between
+ *  {@link ByteBuffer#offset} and {@link ByteBuffer#limit}. This is an alias of {@link ByteBuffer#toBuffer}.
+ * @function
+ * @param {boolean=} forceCopy If `true` returns a copy, otherwise returns a view referencing the same memory.
+ *  Defaults to `false`
+ * @returns {!ArrayBuffer} Contents as an ArrayBuffer
+ * @expose
+ */
+ByteBufferPrototype.toArrayBuffer = ByteBufferPrototype.toBuffer;
+//? }
+

package/node_modules/bytebuffer/src/methods/toString.js

@@ -0,0 +1,43 @@
+/**
+ * Converts the ByteBuffer's contents to a string.
+ * @param {string=} encoding Output encoding. Returns an informative string representation if omitted but also allows
+ *  direct conversion to "utf8", "hex", "base64" and "binary" encoding. "debug" returns a hex representation with
+ *  highlighted offsets.
+ * @param {number=} begin Offset to begin at, defaults to {@link ByteBuffer#offset}
+ * @param {number=} end Offset to end at, defaults to {@link ByteBuffer#limit}
+ * @returns {string} String representation
+ * @throws {Error} If `encoding` is invalid
+ * @expose
+ */
+ByteBufferPrototype.toString = function(encoding, begin, end) {
+    if (typeof encoding === 'undefined')
+        return "ByteBuffer/*?= NODE ? 'NB' : 'AB'+(DATAVIEW ? '_DataView' : '') */(offset="+this.offset+",markedOffset="+this.markedOffset+",limit="+this.limit+",capacity="+this.capacity()+")";
+    if (typeof encoding === 'number')
+        encoding = "utf8",
+        begin = encoding,
+        end = begin;
+    switch (encoding) {
+        //? if (ENCODINGS) {
+        //? if (UTF8) {
+        case "utf8":
+            return this.toUTF8(begin, end);
+        //? } if (BASE64) {
+        case "base64":
+            return this.toBase64(begin, end);
+        //? } if (HEX) {
+        case "hex":
+            return this.toHex(begin, end);
+        //? } if (BINARY) {
+        case "binary":
+            return this.toBinary(begin, end);
+        //? } if (DEBUG) {
+        case "debug":
+            return this.toDebug();
+        case "columns":
+            return this.toColumns();
+        //? }
+        //? } // ENCODINGS
+        default:
+            throw Error("Unsupported encoding: "+encoding);
+    }
+};

package/node_modules/bytebuffer/src/types/bytes/bitset.js

@@ -0,0 +1,89 @@
+/**
+ * Writes the array as a bitset.
+ * @param {Array<boolean>} value Array of booleans to write
+ * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by `length` if omitted.
+ * @returns {!ByteBuffer}
+ * @expose
+ */
+ByteBufferPrototype.writeBitSet = function(value, offset) {
+  //? RELATIVE()  
+  if (!this.noAssert) {
+    if (!(value instanceof Array))
+      throw TypeError("Illegal BitSet: Not an array");
+    //? ASSERT_OFFSET();
+  }
+
+  var start = offset,
+      bits = value.length,
+      bytes = (bits >> 3),
+      bit = 0,
+      k;
+
+  offset += this.writeVarint32(bits,offset);
+
+  while(bytes--) {
+    k = (!!value[bit++] & 1) |
+        ((!!value[bit++] & 1) << 1) |
+        ((!!value[bit++] & 1) << 2) |
+        ((!!value[bit++] & 1) << 3) |
+        ((!!value[bit++] & 1) << 4) |
+        ((!!value[bit++] & 1) << 5) |
+        ((!!value[bit++] & 1) << 6) |
+        ((!!value[bit++] & 1) << 7);
+    this.writeByte(k,offset++);
+  }
+
+  if(bit < bits) {
+    var m = 0; k = 0;
+    while(bit < bits) k = k | ((!!value[bit++] & 1) << (m++));
+    this.writeByte(k,offset++);
+  }
+
+  if (relative) {
+    this.offset = offset;
+    return this;
+  }
+  return offset - start;
+}
+
+/**
+ * Reads a BitSet as an array of booleans.
+ * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by `length` if omitted.
+ * @returns {Array<boolean>
+ * @expose
+ */
+ByteBufferPrototype.readBitSet = function(offset) {
+  //? RELATIVE()  
+
+  var ret = this.readVarint32(offset),
+      bits = ret.value,
+      bytes = (bits >> 3),
+      bit = 0,
+      value = [],
+      k;
+
+  offset += ret.length;
+
+  while(bytes--) {
+    k = this.readByte(offset++);
+    value[bit++] = !!(k & 0x01);
+    value[bit++] = !!(k & 0x02);
+    value[bit++] = !!(k & 0x04);
+    value[bit++] = !!(k & 0x08);
+    value[bit++] = !!(k & 0x10);
+    value[bit++] = !!(k & 0x20);
+    value[bit++] = !!(k & 0x40);
+    value[bit++] = !!(k & 0x80);
+  }
+
+  if(bit < bits) {
+    var m = 0;
+    k = this.readByte(offset++);
+    while(bit < bits) value[bit++] = !!((k >> (m++)) & 1);
+  }
+
+  if (relative) {
+    this.offset = offset;
+  }
+  return value;
+}

package/node_modules/bytebuffer/src/types/bytes/bytes.js

@@ -0,0 +1,34 @@
+/**
+ * Reads the specified number of bytes.
+ * @param {number} length Number of bytes to read
+ * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by `length` if omitted.
+ * @returns {!ByteBuffer}
+ * @expose
+ */
+ByteBufferPrototype.readBytes = function(length, offset) {
+    //? RELATIVE();
+    if (!this.noAssert) {
+        //? ASSERT_OFFSET('length');
+    }
+    var slice = this.slice(offset, offset + length);
+    //? RELATIVE('length');
+    return slice;
+};
+
+/**
+ * Writes a payload of bytes. This is an alias of {@link ByteBuffer#append}.
+ * @function
+ //? if (NODE) {
+ * @param {!ByteBuffer|!Buffer|!ArrayBuffer|!Uint8Array|string} source Data to write. If `source` is a ByteBuffer, its
+ * offsets will be modified according to the performed read operation.
+ //? } else {
+ * @param {!ByteBuffer|!ArrayBuffer|!Uint8Array|string} source Data to write. If `source` is a ByteBuffer, its offsets
+ *  will be modified according to the performed read operation.
+ //? }
+ * @param {(string|number)=} encoding Encoding if `data` is a string ("base64", "hex", "binary", defaults to "utf8")
+ * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by the number of bytes
+ *  written if omitted.
+ * @returns {!ByteBuffer} this
+ * @expose
+ */
+ByteBufferPrototype.writeBytes = ByteBufferPrototype.append;

package/node_modules/bytebuffer/src/types/floats/float32.js

@@ -0,0 +1,81 @@
+//? if (FLOAT32) {
+// types/floats/float32
+//? if (!NODE && !DATAVIEW) {
+
+//? include("ieee754.js");
+//? }
+
+/**
+ * Writes a 32bit float.
+ * @param {number} value Value to write
+ * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by `4` if omitted.
+ * @returns {!ByteBuffer} this
+ * @expose
+ */
+ByteBufferPrototype.writeFloat32 = function(value, offset) {
+    //? RELATIVE();
+    if (!this.noAssert) {
+        if (typeof value !== 'number')
+            throw TypeError("Illegal value: "+value+" (not a number)");
+        //? ASSERT_OFFSET();
+    }
+    //? ENSURE_CAPACITY(4);
+    //? if (NODE) { // FIXME: Is there any way to inline the following in a sane way?
+    this.littleEndian
+        ? this.buffer.writeFloatLE(value, offset, true)
+        : this.buffer.writeFloatBE(value, offset, true);
+    //? } else if (DATAVIEW)
+    this.view.setFloat32(offset, value, this.littleEndian);
+    //? else
+    ieee754_write(this.view, value, offset, this.littleEndian, 23, 4);
+    //? RELATIVE(4);
+    return this;
+};
+//? if (ALIASES) {
+
+/**
+ * Writes a 32bit float. This is an alias of {@link ByteBuffer#writeFloat32}.
+ * @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.
+ * @returns {!ByteBuffer} this
+ * @expose
+ */
+ByteBufferPrototype.writeFloat = ByteBufferPrototype.writeFloat32;
+//? }
+
+/**
+ * Reads a 32bit float.
+ * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by `4` if omitted.
+ * @returns {number}
+ * @expose
+ */
+ByteBufferPrototype.readFloat32 = function(offset) {
+    //? RELATIVE();
+    if (!this.noAssert) {
+        //? ASSERT_OFFSET(4);
+    }
+    //? if (NODE) {
+    var value = this.littleEndian
+        ? this.buffer.readFloatLE(offset, true)
+        : this.buffer.readFloatBE(offset, true);
+    //? } else if (DATAVIEW)
+    var value = this.view.getFloat32(offset, this.littleEndian);
+    //? else
+    var value = ieee754_read(this.view, offset, this.littleEndian, 23, 4);
+    //? RELATIVE(4);
+    return value;
+};
+//? if (ALIASES) {
+
+/**
+ * Reads a 32bit float. This is an alias of {@link ByteBuffer#readFloat32}.
+ * @function
+ * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by `4` if omitted.
+ * @returns {number}
+ * @expose
+ */
+ByteBufferPrototype.readFloat = ByteBufferPrototype.readFloat32;
+//? }
+
+//? }

package/node_modules/bytebuffer/src/types/floats/float64.js

@@ -0,0 +1,77 @@
+//? if (FLOAT64) {
+// types/floats/float64
+
+/**
+ * Writes a 64bit float.
+ * @param {number} 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.writeFloat64 = function(value, offset) {
+    //? RELATIVE();
+    if (!this.noAssert) {
+        if (typeof value !== 'number')
+            throw TypeError("Illegal value: "+value+" (not a number)");
+        //? ASSERT_OFFSET();
+    }
+    //? ENSURE_CAPACITY(8);
+    //? if (NODE) {
+    this.littleEndian
+        ? this.buffer.writeDoubleLE(value, offset, true)
+        : this.buffer.writeDoubleBE(value, offset, true);
+    //? } else if (DATAVIEW)
+    this.view.setFloat64(offset, value, this.littleEndian);
+    //? else
+    ieee754_write(this.view, value, offset, this.littleEndian, 52, 8);
+    //? RELATIVE(8);
+    return this;
+};
+//? if (ALIASES) {
+
+/**
+ * Writes a 64bit float. This is an alias of {@link ByteBuffer#writeFloat64}.
+ * @function
+ * @param {number} 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.writeDouble = ByteBufferPrototype.writeFloat64;
+//? }
+
+/**
+ * Reads a 64bit float.
+ * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by `8` if omitted.
+ * @returns {number}
+ * @expose
+ */
+ByteBufferPrototype.readFloat64 = function(offset) {
+    //? RELATIVE();
+    if (!this.noAssert) {
+        //? ASSERT_OFFSET(8);
+    }
+    //? if (NODE) {
+    var value = this.littleEndian
+        ? this.buffer.readDoubleLE(offset, true)
+        : this.buffer.readDoubleBE(offset, true);
+    //? } else if (DATAVIEW)
+    var value = this.view.getFloat64(offset, this.littleEndian);
+    //? else
+    var value = ieee754_read(this.view, offset, this.littleEndian, 52, 8);
+    //? RELATIVE(8);
+    return value;
+};
+//? if (ALIASES) {
+
+/**
+ * Reads a 64bit float. This is an alias of {@link ByteBuffer#readFloat64}.
+ * @function
+ * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by `8` if omitted.
+ * @returns {number}
+ * @expose
+ */
+ByteBufferPrototype.readDouble = ByteBufferPrototype.readFloat64;
+//? }
+
+//? }

package/node_modules/bytebuffer/src/types/floats/ieee754.js

@@ -0,0 +1,130 @@
+/*
+ ieee754 - https://github.com/feross/ieee754
+
+ The MIT License (MIT)
+
+ Copyright (c) Feross Aboukhadijeh
+
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated documentation files (the "Software"), to deal
+ in the Software without restriction, including without limitation the rights
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the Software is
+ furnished to do so, subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be included in
+ all copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ THE SOFTWARE.
+*/
+
+/**
+ * Reads an IEEE754 float from a byte array.
+ * @param {!Array} buffer
+ * @param {number} offset
+ * @param {boolean} isLE
+ * @param {number} mLen
+ * @param {number} nBytes
+ * @returns {number}
+ * @inner
+ */
+function ieee754_read(buffer, offset, isLE, mLen, nBytes) {
+    var e, m,
+        eLen = nBytes * 8 - mLen - 1,
+        eMax = (1 << eLen) - 1,
+        eBias = eMax >> 1,
+        nBits = -7,
+        i = isLE ? (nBytes - 1) : 0,
+        d = isLE ? -1 : 1,
+        s = buffer[offset + i];
+
+    i += d;
+
+    e = s & ((1 << (-nBits)) - 1);
+    s >>= (-nBits);
+    nBits += eLen;
+    for (; nBits > 0; e = e * 256 + buffer[offset + i], i += d, nBits -= 8) {}
+
+    m = e & ((1 << (-nBits)) - 1);
+    e >>= (-nBits);
+    nBits += mLen;
+    for (; nBits > 0; m = m * 256 + buffer[offset + i], i += d, nBits -= 8) {}
+
+    if (e === 0) {
+        e = 1 - eBias;
+    } else if (e === eMax) {
+        return m ? NaN : ((s ? -1 : 1) * Infinity);
+    } else {
+        m = m + Math.pow(2, mLen);
+        e = e - eBias;
+    }
+    return (s ? -1 : 1) * m * Math.pow(2, e - mLen);
+}
+
+/**
+ * Writes an IEEE754 float to a byte array.
+ * @param {!Array} buffer
+ * @param {number} value
+ * @param {number} offset
+ * @param {boolean} isLE
+ * @param {number} mLen
+ * @param {number} nBytes
+ * @inner
+ */
+function ieee754_write(buffer, value, offset, isLE, mLen, nBytes) {
+    var e, m, c,
+        eLen = nBytes * 8 - mLen - 1,
+        eMax = (1 << eLen) - 1,
+        eBias = eMax >> 1,
+        rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0),
+        i = isLE ? 0 : (nBytes - 1),
+        d = isLE ? 1 : -1,
+        s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0;
+
+    value = Math.abs(value);
+
+    if (isNaN(value) || value === Infinity) {
+        m = isNaN(value) ? 1 : 0;
+        e = eMax;
+    } else {
+        e = Math.floor(Math.log(value) / Math.LN2);
+        if (value * (c = Math.pow(2, -e)) < 1) {
+            e--;
+            c *= 2;
+        }
+        if (e + eBias >= 1) {
+            value += rt / c;
+        } else {
+            value += rt * Math.pow(2, 1 - eBias);
+        }
+        if (value * c >= 2) {
+            e++;
+            c /= 2;
+        }
+
+        if (e + eBias >= eMax) {
+            m = 0;
+            e = eMax;
+        } else if (e + eBias >= 1) {
+            m = (value * c - 1) * Math.pow(2, mLen);
+            e = e + eBias;
+        } else {
+            m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen);
+            e = 0;
+        }
+    }
+
+    for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8) {}
+
+    e = (e << mLen) | m;
+    eLen += mLen;
+    for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8) {}
+
+    buffer[offset + i - d] |= s * 128;
+}