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

package/node_modules/bytebuffer/node_modules/long/tests/suite.js

@@ -0,0 +1,195 @@
+/*
+ Copyright 2013 Daniel Wirtz <dcode@dcode.io>
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS-IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+ */
+
+var Long = require(__dirname+"/../index.js"),
+    gmLong = require("./goog.math.long.js");
+
+var suite = {
+    
+    "basic": function(test) {
+        var longVal = new Long(0xFFFFFFFF, 0x7FFFFFFF);
+        test.equal(longVal.toNumber(), 9223372036854775807);
+        test.equal(longVal.toString(), "9223372036854775807");
+        var longVal2 = Long.fromValue(longVal);
+        test.equal(longVal2.toNumber(), 9223372036854775807);
+        test.equal(longVal2.toString(), "9223372036854775807");
+        test.equal(longVal2.unsigned, longVal.unsigned);
+        test.done();
+    },
+
+    "isLong": function(test) {
+        var longVal = new Long(0xFFFFFFFF, 0x7FFFFFFF);
+        test.strictEqual(Long.isLong(longVal), true);
+        longVal = {"__isLong__": true};
+        test.strictEqual(Long.isLong(longVal), true);
+        test.done();
+    },
+    
+    // Let's assume goog.math.Long has been tested properly and focus on our extensions:
+    
+    "toString": function(test) {
+        var longVal = Long.fromBits(0xFFFFFFFF, 0xFFFFFFFF, true);
+        // #10
+        test.equal(longVal.toString(16), "ffffffffffffffff");
+        test.equal(longVal.toString(10), "18446744073709551615");
+        test.equal(longVal.toString(8), "1777777777777777777777");
+        // #7, obviously wrong in goog.math.Long
+        test.equal(Long.fromString("zzzzzz", 36).toString(36), "zzzzzz");
+        test.equal(Long.fromString("-zzzzzz", 36).toString(36), "-zzzzzz");
+        test.done();
+    },
+
+    "toBytes": function(test) {
+        var longVal = Long.fromBits(0x01234567, 0x12345678);
+        test.deepEqual(longVal.toBytesBE(), [
+            0x12, 0x34, 0x56, 0x78,
+            0x01, 0x23, 0x45, 0x67
+        ]);
+        test.deepEqual(longVal.toBytesLE(), [
+            0x67, 0x45, 0x23, 0x01,
+            0x78, 0x56, 0x34, 0x12
+        ]);
+        test.done();
+    },
+    
+    "unsigned": {
+        
+        "min/max": function(test) {
+            test.equal(Long.MIN_VALUE.toString(), "-9223372036854775808");
+            test.equal(Long.MAX_VALUE.toString(), "9223372036854775807");
+            test.equal(Long.MAX_UNSIGNED_VALUE.toString(), "18446744073709551615");
+            test.done();
+        },
+        
+        "construct_negint": function(test) {
+            var longVal = Long.fromInt(-1, true);
+            test.equal(longVal.low, -1);
+            test.equal(longVal.high, -1);
+            test.equal(longVal.unsigned, true);
+            test.equal(longVal.toNumber(), 18446744073709551615);
+            test.equal(longVal.toString(), "18446744073709551615");
+            test.done();
+        },
+        
+        "construct_highlow": function(test) {
+            var longVal = new Long(0xFFFFFFFF, 0xFFFFFFFF, true);
+            test.equal(longVal.low, -1);
+            test.equal(longVal.high, -1);
+            test.equal(longVal.unsigned, true);
+            test.equal(longVal.toNumber(), 18446744073709551615);
+            test.equal(longVal.toString(), "18446744073709551615");
+            test.done();
+        },
+        
+        "construct_number": function(test) {
+            var longVal = Long.fromNumber(0xFFFFFFFFFFFFFFFF, true);
+            test.equal(longVal.low, -1);
+            test.equal(longVal.high, -1);
+            test.equal(longVal.unsigned, true);
+            test.equal(longVal.toNumber(), 18446744073709551615);
+            test.equal(longVal.toString(), "18446744073709551615");
+            test.done();
+        },
+
+        "toSigned/Unsigned": function(test) {
+            var longVal = Long.fromNumber(-1, false);
+            test.equal(longVal.toNumber(), -1);
+            longVal = longVal.toUnsigned();
+            test.equal(longVal.toNumber(), 0xFFFFFFFFFFFFFFFF);
+            test.equal(longVal.toString(16), 'ffffffffffffffff');
+            longVal = longVal.toSigned();
+            test.equal(longVal.toNumber(), -1);
+            test.done();
+        },
+        
+        "max_unsigned_sub_max_signed": function(test) {
+            var longVal = Long.MAX_UNSIGNED_VALUE.subtract(Long.MAX_VALUE).subtract(Long.ONE);
+            test.equal(longVal.toNumber(), Long.MAX_VALUE.toNumber());
+            test.equal(longVal.toString(), Long.MAX_VALUE.toString());
+            test.done();
+        },
+        
+        "max_sub_max": function(test) {
+            var longVal = Long.MAX_UNSIGNED_VALUE.subtract(Long.MAX_UNSIGNED_VALUE);
+            test.equal(longVal, 0);
+            test.equal(longVal.low, 0);
+            test.equal(longVal.high, 0);
+            test.equal(longVal.unsigned, true);
+            test.equal(longVal.toNumber(), 0);
+            test.equal(longVal.toString(), "0");
+            test.done();
+        },
+        
+        "zero_sub_signed": function(test) {
+            var longVal = Long.fromInt(0, true).add(Long.fromInt(-1, false));
+            test.equal(longVal.low, -1);
+            test.equal(longVal.high, -1);
+            test.equal(longVal.unsigned, true);
+            test.equal(longVal.toNumber(), 18446744073709551615);
+            test.equal(longVal.toString(), "18446744073709551615");
+            test.done();
+        },
+        
+        "max_unsigned_div_max_signed": function(test) {
+            var longVal = Long.MAX_UNSIGNED_VALUE.div(Long.MAX_VALUE);
+            test.equal(longVal.toNumber(), 2);
+            test.equal(longVal.toString(), "2");
+            test.done();
+        },
+        
+        "max_unsigned_div_max_unsigned": function(test) {
+            var longVal = Long.MAX_UNSIGNED_VALUE;
+            test.strictEqual(longVal.div(longVal).toString(), '1');
+            test.done();
+        },
+        
+        "max_unsigned_div_neg_signed": function(test) {
+            var a = Long.MAX_UNSIGNED_VALUE;
+            var b = Long.fromInt(-2);
+            test.strictEqual(b.toUnsigned().toString(), Long.MAX_UNSIGNED_VALUE.sub(1).toString());
+            var longVal = a.div(b);
+            test.strictEqual(longVal.toString(), '1');
+            test.done();
+        },
+
+        "min_signed_div_one": function(test) {
+            var longVal = Long.MIN_VALUE.div(Long.ONE);
+            test.strictEqual(longVal.toString(), Long.MIN_VALUE.toString());
+            test.done();
+        },
+
+        "msb_unsigned": function(test) {
+            var longVal = Long.UONE.shiftLeft(63);
+            test.ok(longVal.notEquals(Long.MIN_VALUE));
+            test.equal(longVal.toString(), "9223372036854775808");
+            test.equal(Long.fromString("9223372036854775808", true).toString(), "9223372036854775808");
+            test.done();
+        },
+        
+        "issue31": function(test) {
+            var a = new Long(0, 8, true);
+            var b = Long.fromNumber(2656901066, true);
+            test.strictEqual(a.unsigned, true);
+            test.strictEqual(b.unsigned, true);
+            var x = a.div(b);
+            test.strictEqual(x.toString(), '12');
+            test.strictEqual(x.unsigned, true);
+            test.done();
+        }
+    }
+};
+
+module.exports = suite;

package/node_modules/bytebuffer/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "bytebuffer",
+  "version": "5.0.1",
+  "author": "Daniel Wirtz <dcode@dcode.io>",
+  "description": "The swiss army knife for binary data in JavaScript.",
+  "main": "dist/bytebuffer-node.js",
+  "browser": "dist/bytebuffer.js",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/dcodeIO/bytebuffer.js.git"
+  },
+  "bugs": {
+    "url": "https://github.com/dcodeIO/bytebuffer.js/issues"
+  },
+  "keywords": [
+    "net",
+    "array",
+    "buffer",
+    "arraybuffer",
+    "typed array",
+    "bytebuffer",
+    "json",
+    "websocket",
+    "webrtc"
+  ],
+  "dependencies": {
+    "long": "~3"
+  },
+  "devDependencies": {
+    "closurecompiler": "~1",
+    "lxiv": "~0.2",
+    "metascript": "~0",
+    "pretty-hrtime": "^1.0.0",
+    "testjs": "~1",
+    "utfx": "^1.0.1"
+  },
+  "license": "Apache-2.0",
+  "engines": {
+    "node": ">=0.8"
+  },
+  "scripts": {
+    "prepublish": "npm test",
+    "test": "node node_modules/testjs/bin/testjs tests/suite.js",
+    "make": "npm run-script build && npm run-script compile && npm run-script compress && npm test",
+    "build": "node scripts/build.js",
+    "compile": "npm run-script compile-default && npm run-script compile-dataview",
+    "compile-default": "ccjs dist/bytebuffer.js --create_source_map=dist/bytebuffer.min.map --externs=externs/minimal-env.js --externs=node_modules/long/externs/long.js > dist/bytebuffer.min.js",
+    "compile-dataview": "ccjs dist/bytebuffer-dataview.js --create_source_map=dist/bytebuffer-dataview.min.map --externs=externs/minimal-env.js --externs=node_modules/long/externs/long.js > dist/bytebuffer-dataview.min.js",
+    "compress": "gzip -c -9 dist/bytebuffer.min.js > dist/bytebuffer.min.js.gz && gzip -c -9 dist/bytebuffer-dataview.min.js > dist/bytebuffer-dataview.min.js.gz"
+  }
+}

package/node_modules/bytebuffer/scripts/build.js

@@ -0,0 +1,113 @@
+/*
+ Copyright 2013 Daniel Wirtz <dcode@dcode.io>
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+ */
+
+var MetaScript = require("metascript"),
+    path = require("path"),
+    fs = require("fs");
+
+var rootDir = path.join(__dirname, ".."),
+    srcDir  = path.join(__dirname, "..", "src"),
+    distDir = path.join(__dirname, "..", "dist"),
+    pkg = require(path.join(rootDir, "package.json")),
+    filename;
+
+var scope = {
+    VERSION    : pkg.version,           // Version
+    
+    // Encodings
+    
+    ENCODINGS  : true,                  // Include encodings in general (catches all)
+    BASE64     : true,                  // Include base64 encoding
+    BINARY     : true,                  // Include binary encoding
+    DEBUG      : true,                  // Include debug encoding
+    HEX        : true,                  // Include hex encoding
+    UTF8       : true,                  // Include utf8 encoding (required for STRINGS)
+    
+    // Primitive types
+
+    BYTES      : true,                  // Include bytes
+    INTS       : true,                  // Include int types in general (catches all)
+    INT8       : true,                  // Include int8/uint8
+    INT16      : true,                  // Include int16/uint16
+    INT32      : true,                  // Include int32/uint32
+    INT64      : true,                  // Include int64/uint64 with Long.js
+    
+    FLOATS     : true,                  // Include float types in general (catches all)
+    FLOAT32    : true,                  // Include float32
+    FLOAT64    : true,                  // Include float64
+    
+    // Varint encoding
+    
+    VARINTS    : true,                  // Include varint encoding in general (catches all)
+    VARINT32   : true,                  // Include varint32/zigZagVarint32
+    VARINT64   : true,                  // Include varint64/zigZagVarint32 with Long.js
+    
+    // String support
+    
+    STRINGS    : true,                  // Include string support in general (catches all)
+    UTF8STRING : true,                  // Include UTF8 encoded strings
+    CSTRING    : true,                  // Include C-like null terminated strings
+    VSTRING    : true,                  // Include varint32 length prefixed strings
+    ISTRING    : true,                  // Include uint32 length prefixed strings
+    
+    // Other
+    
+    ALIASES    : true,                  // Include aliases like writeByte, writeShort ..
+    INLINE     : true,                  // Inline any assertion code
+    VERBOSE_MS : false                  // Include MetaScript details as comments
+};
+
+// Optimize for size  : INLINE=false, ALIASES=false, VERBOSE_MS=false, WHATEVERYOUDONTNEED=false
+// Optimize for speed : INLINE=true
+
+if (!scope.UTF8) scope.STRINGS = false;
+
+// Build node version using Buffers
+scope.NODE = true;
+console.log("Building bytebuffer-node with scope", JSON.stringify(scope, null, 2));
+fs.writeFileSync(
+    path.join(distDir, "bytebuffer-node.js"),
+    MetaScript.transform(fs.readFileSync(filename = path.join(srcDir, "wrap-node.js")), filename, scope, srcDir)
+);
+
+// Build browser version using Typed Arrays
+scope.NODE = false;
+scope.DATAVIEW = false;
+delete scope.BUFFERVIEW;
+console.log("Building bytebuffer.js with scope", JSON.stringify(scope, null, 2));
+fs.writeFileSync(
+    path.join(distDir, "bytebuffer.js"),
+    MetaScript.transform(fs.readFileSync(filename = path.join(srcDir, "wrap.js")), filename, scope)
+);
+
+// Build alternative browser version using a DataView
+scope.NODE = false;
+scope.DATAVIEW = true;
+console.log("Building bytebuffer-dataview with scope", JSON.stringify(scope, null, 2));
+fs.writeFileSync(
+    path.join(distDir, "bytebuffer-dataview.js"),
+    MetaScript.transform(fs.readFileSync(filename = path.join(srcDir, "wrap.js")), filename, scope)
+);
+
+// Update bower.json
+scope = { VERSION: pkg.version };
+console.log("Updating bower.json with scope", JSON.stringify(scope, null, 2));
+fs.writeFileSync(
+    path.join(rootDir, "bower.json"),
+    MetaScript.transform(fs.readFileSync(filename = path.join(srcDir, "bower.json")), filename, scope, srcDir)
+);
+
+console.log("Done");

package/node_modules/bytebuffer/src/bower.json

@@ -0,0 +1,12 @@
+{
+    "name": "bytebuffer",
+    "version": "/*?= VERSION */",
+    "author": "Daniel Wirtz <dcode@dcode.io>",
+    "description": "A full-featured ByteBuffer implementation using typed arrays.",
+    "main": "dist/bytebuffer.js",
+    "keywords": ["net", "array", "buffer", "arraybuffer", "typed array", "bytebuffer", "json", "websocket", "webrtc"],
+    "dependencies": {
+        "long": "latest"
+    },
+    "license": "Apache-2.0"
+}

package/node_modules/bytebuffer/src/bytebuffer.js

@@ -0,0 +1,220 @@
+//? include("macros.js");
+/**
+ * Constructs a new ByteBuffer.
+ * @class The swiss army knife for binary data in JavaScript.
+ * @exports ByteBuffer
+ * @constructor
+ * @param {number=} capacity Initial capacity. Defaults to {@link ByteBuffer.DEFAULT_CAPACITY}.
+ * @param {boolean=} littleEndian Whether to use little or big endian byte order. Defaults to
+ *  {@link ByteBuffer.DEFAULT_ENDIAN}.
+ * @param {boolean=} noAssert Whether to skip assertions of offsets and values. Defaults to
+ *  {@link ByteBuffer.DEFAULT_NOASSERT}.
+ * @expose
+ */
+var ByteBuffer = function(capacity, littleEndian, noAssert) {
+    if (typeof capacity === 'undefined')
+        capacity = ByteBuffer.DEFAULT_CAPACITY;
+    if (typeof littleEndian === 'undefined')
+        littleEndian = ByteBuffer.DEFAULT_ENDIAN;
+    if (typeof noAssert === 'undefined')
+        noAssert = ByteBuffer.DEFAULT_NOASSERT;
+    if (!noAssert) {
+        capacity = capacity | 0;
+        if (capacity < 0)
+            throw RangeError("Illegal capacity");
+        littleEndian = !!littleEndian;
+        noAssert = !!noAssert;
+    }
+    //? if (NODE) {
+    
+    /**
+     * Backing node Buffer.
+     * @type {!Buffer}
+     * @expose
+     */
+    this.buffer = capacity === 0 ? EMPTY_BUFFER : new Buffer(capacity);
+    //? } else {
+    
+    /**
+     * Backing ArrayBuffer.
+     * @type {!ArrayBuffer}
+     * @expose
+     */
+    this.buffer = capacity === 0 ? EMPTY_BUFFER : new ArrayBuffer(capacity);
+
+    //? if (DATAVIEW) {
+    /**
+     * DataView utilized to manipulate the backing buffer. Becomes `null` if the backing buffer has a capacity of `0`.
+     * @type {?DataView}
+     * @expose
+     */
+    this.view = capacity === 0 ? null : new DataView(this.buffer);
+    //? } else {
+    /**
+     * Uint8Array utilized to manipulate the backing buffer. Becomes `null` if the backing buffer has a capacity of `0`.
+     * @type {?Uint8Array}
+     * @expose
+     */
+    this.view = capacity === 0 ? null : new Uint8Array(this.buffer);
+    //? }
+    //? }
+    
+    /**
+     * Absolute read/write offset.
+     * @type {number}
+     * @expose
+     * @see ByteBuffer#flip
+     * @see ByteBuffer#clear
+     */
+    this.offset = 0;
+
+    /**
+     * Marked offset.
+     * @type {number}
+     * @expose
+     * @see ByteBuffer#mark
+     * @see ByteBuffer#reset
+     */
+    this.markedOffset = -1;
+
+    /**
+     * Absolute limit of the contained data. Set to the backing buffer's capacity upon allocation.
+     * @type {number}
+     * @expose
+     * @see ByteBuffer#flip
+     * @see ByteBuffer#clear
+     */
+    this.limit = capacity;
+
+    /**
+     * Whether to use little endian byte order, defaults to `false` for big endian.
+     * @type {boolean}
+     * @expose
+     */
+    this.littleEndian = littleEndian;
+
+    /**
+     * Whether to skip assertions of offsets and values, defaults to `false`.
+     * @type {boolean}
+     * @expose
+     */
+    this.noAssert = noAssert;
+};
+
+/**
+ * ByteBuffer version.
+ * @type {string}
+ * @const
+ * @expose
+ */
+ByteBuffer.VERSION = "/*?= VERSION */";
+
+/**
+ * Little endian constant that can be used instead of its boolean value. Evaluates to `true`.
+ * @type {boolean}
+ * @const
+ * @expose
+ */
+ByteBuffer.LITTLE_ENDIAN = true;
+
+/**
+ * Big endian constant that can be used instead of its boolean value. Evaluates to `false`.
+ * @type {boolean}
+ * @const
+ * @expose
+ */
+ByteBuffer.BIG_ENDIAN = false;
+
+/**
+ * Default initial capacity of `16`.
+ * @type {number}
+ * @expose
+ */
+ByteBuffer.DEFAULT_CAPACITY = 16;
+
+/**
+ * Default endianess of `false` for big endian.
+ * @type {boolean}
+ * @expose
+ */
+ByteBuffer.DEFAULT_ENDIAN = ByteBuffer.BIG_ENDIAN;
+
+/**
+ * Default no assertions flag of `false`.
+ * @type {boolean}
+ * @expose
+ */
+ByteBuffer.DEFAULT_NOASSERT = false;
+//? if (NODE) {
+
+/**
+ * A `Long` class for representing a 64-bit two's-complement integer value.
+ * @type {!Long}
+ * @const
+ * @see https://npmjs.org/package/long
+ * @expose
+ */
+ByteBuffer.Long = Long;
+//? } else {
+
+/**
+ * A `Long` class for representing a 64-bit two's-complement integer value. May be `null` if Long.js has not been loaded
+ *  and int64 support is not available.
+ * @type {?Long}
+ * @const
+ * @see https://github.com/dcodeIO/long.js
+ * @expose
+ */
+ByteBuffer.Long = Long || null;
+//? }
+
+/**
+ * @alias ByteBuffer.prototype
+ * @inner
+ */
+var ByteBufferPrototype = ByteBuffer.prototype;
+
+/**
+ * An indicator used to reliably determine if an object is a ByteBuffer or not.
+ * @type {boolean}
+ * @const
+ * @expose
+ * @private
+ */
+ByteBufferPrototype.__isByteBuffer__;
+
+Object.defineProperty(ByteBufferPrototype, "__isByteBuffer__", {
+    value: true,
+    enumerable: false,
+    configurable: false
+});
+
+//? include("helpers.js");
+
+//? include("methods/static/*.js");
+//? if (BYTES) {
+
+//? include("types/bytes/*.js");
+//? }
+//? if (INTS) {
+
+//? include("types/ints/*.js");
+//? }
+//? if (FLOATS) {
+
+//? include("types/floats/float*.js");
+//? }
+//? if (VARINTS) {
+
+//? include("types/varints/*.js");
+//? }
+//? if (UTF8 && STRINGS) {
+
+//? include("types/strings/*.js");
+//? }
+
+//? include("methods/*.js");
+//? if (ENCODINGS) {
+
+//? include("encodings/*.js");
+//? }

package/node_modules/bytebuffer/src/encodings/base64.js

@@ -0,0 +1,88 @@
+//? if (BASE64) {
+//? if (!NODE) {
+// lxiv-embeddable
+
+//? include("../../node_modules/lxiv/dist/lxiv-embeddable.js");
+
+//? }
+// encodings/base64
+
+/**
+ * Encodes this ByteBuffer's contents to a base64 encoded string.
+ * @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} Base64 encoded string
+ * @throws {RangeError} If `begin` or `end` is out of bounds
+ * @expose
+ */
+ByteBufferPrototype.toBase64 = function(begin, end) {
+    if (typeof begin === 'undefined')
+        begin = this.offset;
+    if (typeof end === 'undefined')
+        end = this.limit;
+    begin = begin | 0; end = end | 0;
+    if (begin < 0 || end > this.capacity || begin > end)
+        throw RangeError("begin, end");
+    //? if (NODE)
+    return this.buffer.toString("base64", begin, end);
+    //? else {
+    var sd; lxiv.encode(function() {
+        //? if (DATAVIEW)
+        return begin < end ? this.view.getUint8(begin++) : null;
+        //? else
+        return begin < end ? this.view[begin++] : null;
+    }.bind(this), sd = stringDestination());
+    return sd();
+    //? }
+};
+
+/**
+ * Decodes a base64 encoded string to a ByteBuffer.
+ * @param {string} str String to decode
+ * @param {boolean=} littleEndian Whether to use little or big endian byte order. Defaults to
+ *  {@link ByteBuffer.DEFAULT_ENDIAN}.
+ * @returns {!ByteBuffer} ByteBuffer
+ * @expose
+ */
+ByteBuffer.fromBase64 = function(str, littleEndian) {
+    //? if (NODE) {
+    return ByteBuffer.wrap(new Buffer(str, "base64"), littleEndian);
+    //? } else {
+    if (typeof str !== 'string')
+        throw TypeError("str");
+    var bb = new ByteBuffer(str.length/4*3, littleEndian),
+        i = 0;
+    lxiv.decode(stringSource(str), function(b) {
+        //? if (DATAVIEW)
+        bb.view.setUint8(i++, b);
+        //? else
+        bb.view[i++] = b;
+    });
+    bb.limit = i;
+    //? }
+    return bb;
+};
+
+/**
+ * Encodes a binary string to base64 like `window.btoa` does.
+ * @param {string} str Binary string
+ * @returns {string} Base64 encoded string
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/Window.btoa
+ * @expose
+ */
+ByteBuffer.btoa = function(str) {
+    return ByteBuffer.fromBinary(str).toBase64();
+};
+
+/**
+ * Decodes a base64 encoded string to binary like `window.atob` does.
+ * @param {string} b64 Base64 encoded string
+ * @returns {string} Binary string
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/Window.atob
+ * @expose
+ */
+ByteBuffer.atob = function(b64) {
+    return ByteBuffer.fromBase64(b64).toBinary();
+};
+
+//? }