node-firebird 1.1.10 → 2.0.1

package/lib/wire/serialize.js

@@ -13,135 +13,149 @@ function align(n) {
 const
     MAX_STRING_SIZE = 255;
 
-var BlrWriter = exports.BlrWriter = function(size){
-    this.buffer = Buffer.alloc(size || 32);
-    this.pos = 0;
-};
-
-BlrWriter.prototype.addByte = function (b) {
-    this.ensure(1);
-    this.buffer.writeUInt8(b, this.pos);
-    this.pos++;
-};
-
-BlrWriter.prototype.addShort = function (b) {
-    this.ensure(1);
-    this.buffer.writeInt8(b, this.pos);
-    this.pos++;
-};
-
-BlrWriter.prototype.addSmall = function (b) {
-    this.ensure(2);
-    this.buffer.writeInt16LE(b, this.pos);
-    this.pos += 2;
-};
-
-BlrWriter.prototype.addWord = function (b) {
-    this.ensure(2);
-    this.buffer.writeUInt16LE(b, this.pos);
-    this.pos += 2;
-};
-
-BlrWriter.prototype.addInt32 = function (b) {
-    this.ensure(4);
-    this.buffer.writeUInt32LE(b, this.pos);
-    this.pos += 4;
-};
-
-BlrWriter.prototype.addByteInt32 = function (c, b) {
-    this.addByte(c);
-    this.ensure(4);
-    this.buffer.writeUInt32LE(b, this.pos);
-    this.pos += 4;
-};
-
-BlrWriter.prototype.addNumeric = function (c, v) {
-
-    if (v < 256){
-        this.ensure(3);
-        this.buffer.writeUInt8(c, this.pos);
-        this.pos++;
-        this.buffer.writeUInt8(1, this.pos);
+class BlrWriter {
+    constructor(size) {
+        this.buffer = Buffer.alloc(size || 32);
+        this.pos = 0;
+    }
+
+    ensure(len) {
+        var newlen = this.buffer.length;
+
+        while (newlen < this.pos + len)
+            newlen *= 2
+
+        if (this.buffer.length >= newlen)
+            return;
+
+        var b = Buffer.alloc(newlen);
+        this.buffer.copy(b);
+        delete(this.buffer);
+        this.buffer = b;
+    }
+
+    addByte(b) {
+        this.ensure(1);
+        this.buffer.writeUInt8(b, this.pos);
         this.pos++;
-        this.buffer.writeUInt8(v, this.pos);
+    }
+
+    addShort(b) {
+        this.ensure(1);
+        this.buffer.writeInt8(b, this.pos);
         this.pos++;
-        return;
     }
 
-    this.ensure(6);
-    this.buffer.writeUInt8(c, this.pos);
-    this.pos++;
-    this.buffer.writeUInt8(4, this.pos);
-    this.pos++;
-    this.buffer.writeInt32BE(v, this.pos);
-    this.pos += 4;
+    addSmall(b) {
+        this.ensure(2);
+        this.buffer.writeInt16LE(b, this.pos);
+        this.pos += 2;
+    }
 
-};
+    addWord(b) {
+        this.ensure(2);
+        this.buffer.writeUInt16LE(b, this.pos);
+        this.pos += 2;
+    }
 
-BlrWriter.prototype.addBytes = function (b) {
+    addInt32(b) {
+        this.ensure(4);
+        this.buffer.writeUInt32LE(b, this.pos);
+        this.pos += 4;
+    }
 
-    this.ensure(b.length);
-    for (var i = 0, length = b.length; i < length; i++) {
-        this.buffer.writeUInt8(b[i], this.pos);
+    addByteInt32(c, b) {
+        this.addByte(c);
+        this.ensure(4);
+        this.buffer.writeUInt32LE(b, this.pos);
+        this.pos += 4;
+    }
+
+    addNumeric(c, v) {
+        if (v < 256){
+            this.ensure(3);
+            this.buffer.writeUInt8(c, this.pos);
+            this.pos++;
+            this.buffer.writeUInt8(1, this.pos);
+            this.pos++;
+            this.buffer.writeUInt8(v, this.pos);
+            this.pos++;
+            return;
+        }
+
+        this.ensure(6);
+        this.buffer.writeUInt8(c, this.pos);
+        this.pos++;
+        this.buffer.writeUInt8(4, this.pos);
         this.pos++;
+        this.buffer.writeInt32BE(v, this.pos);
+        this.pos += 4;
     }
-};
 
-BlrWriter.prototype.addString = function (c, s, encoding) {
-    this.addByte(c);
+    addBytes(b) {
+        this.ensure(b.length);
+        for (var i = 0, length = b.length; i < length; i++) {
+            this.buffer.writeUInt8(b[i], this.pos);
+            this.pos++;
+        }
+    }
 
-    var len = Buffer.byteLength(s, encoding);
-    if (len > MAX_STRING_SIZE)
-        throw new Error('blr string is too big');
+    addString(c, s, encoding) {
+        this.addByte(c);
 
-    this.ensure(len + 1);
-    this.buffer.writeUInt8(len, this.pos);
-    this.pos++;
-    this.buffer.write(s, this.pos, len, encoding);
-    this.pos += len;
-};
+        var len = Buffer.byteLength(s, encoding);
+        if (len > MAX_STRING_SIZE)
+            throw new Error('blr string is too big');
 
-BlrWriter.prototype.addBuffer = function (b) {
-    this.addWord(b.length);
-    this.ensure(b.length);
-    b.copy(this.buffer, this.pos);
-    this.pos += b.length;
-};
+        this.ensure(len + 1);
+        this.buffer.writeUInt8(len, this.pos);
+        this.pos++;
+        this.buffer.write(s, this.pos, len, encoding);
+        this.pos += len;
+    }
 
-BlrWriter.prototype.addString2 = function (c, s, encoding) {
-    this.addByte(c);
+    addBuffer(b) {
+        this.addWord(b.length);
+        this.ensure(b.length);
+        b.copy(this.buffer, this.pos);
+        this.pos += b.length;
+    }
 
-    var len = Buffer.byteLength(s, encoding);
-    if (len > MAX_STRING_SIZE* MAX_STRING_SIZE)
-        throw new Error('blr string is too big');
+    addString2(c, s, encoding) {
+        this.addByte(c);
 
-    this.ensure(len + 2);
-    this.buffer.writeUInt16LE(len, this.pos);
-    this.pos += 2;
-    this.buffer.write(s, this.pos, len, encoding);
-    this.pos += len;
-};
+        var len = Buffer.byteLength(s, encoding);
+        if (len > MAX_STRING_SIZE* MAX_STRING_SIZE)
+            throw new Error('blr string is too big');
 
-BlrWriter.prototype.addMultiblockPart = function (c, s, encoding) {
-    var buff = Buffer.from(s, encoding);
-    var remaining = buff.length;
-    var step = 0;
+        this.ensure(len + 2);
+        this.buffer.writeUInt16LE(len, this.pos);
+        this.pos += 2;
+        this.buffer.write(s, this.pos, len, encoding);
+        this.pos += len;
+    }
 
-    while (remaining > 0) {
-        var toWrite = Math.min(remaining, 254);
+    addMultiblockPart(c, s, encoding) {
+        var buff = Buffer.from(s, encoding);
+        var remaining = buff.length;
+        var step = 0;
 
-        this.addByte(c);
-        this.addByte(toWrite + 1);
-        this.addByte(step);
+        while (remaining > 0) {
+            var toWrite = Math.min(remaining, 254);
 
-        this.ensure(toWrite);
-        buff.copy(this.buffer, this.pos, step * 254, (step * 254) + toWrite);
+            this.addByte(c);
+            this.addByte(toWrite + 1);
+            this.addByte(step);
 
-        step++;
-        remaining -= toWrite;
-        this.pos += toWrite;
+            this.ensure(toWrite);
+            buff.copy(this.buffer, this.pos, step * 254, (step * 254) + toWrite);
+
+            step++;
+            remaining -= toWrite;
+            this.pos += toWrite;
+        }
     }
-};
+}
 
 /***************************************
  *
@@ -149,83 +163,83 @@ BlrWriter.prototype.addMultiblockPart = function (c, s, encoding) {
  *
  ***************************************/
 
-var BlrReader = exports.BlrReader = function(buffer) {
-    this.buffer = buffer;
-    this.pos = 0;
-};
-
-BlrReader.prototype.readByteCode = function(){
-    return this.buffer.readUInt8(this.pos++);
-};
+class BlrReader {
+    constructor(buffer) {
+        this.buffer = buffer;
+        this.pos = 0;
+    }
 
-BlrReader.prototype.readInt32 = function () {
-    var value = this.buffer.readUInt32LE(this.pos);
-    this.pos += 4;
-    return value;
-}
+    readByteCode() {
+        return this.buffer.readUInt8(this.pos++);
+    }
 
-BlrReader.prototype.readInt = function(){
-    var len = this.buffer.readUInt16LE(this.pos);
-    this.pos += 2;
-    var value;
-    switch (len) {
-        case 1:
-            value = this.buffer.readInt8(this.pos);
-            break;
-        case 2:
-            value = this.buffer.readInt16LE(this.pos);
-            break;
-        case 4:
-            value = this.buffer.readInt32LE(this.pos)
+    readInt32() {
+        var value = this.buffer.readUInt32LE(this.pos);
+        this.pos += 4;
+        return value;
     }
-    this.pos += len;
-    return value;
-};
 
-BlrReader.prototype.readString = function(encoding){
+    readInt() {
+        var len = this.buffer.readUInt16LE(this.pos);
+        this.pos += 2;
+        var value;
+        switch (len) {
+            case 1:
+                value = this.buffer.readInt8(this.pos);
+                break;
+            case 2:
+                value = this.buffer.readInt16LE(this.pos);
+                break;
+            case 4:
+                value = this.buffer.readInt32LE(this.pos)
+        }
+        this.pos += len;
+        return value;
+    }
 
-    var len = this.buffer.readUInt16LE(this.pos);
-    var str;
+    readString(encoding) {
+        var len = this.buffer.readUInt16LE(this.pos);
+        var str;
 
-    this.pos += 2;
-    if (len <= 0)
-        return '';
+        this.pos += 2;
+        if (len <= 0)
+            return '';
 
-    str = this.buffer.toString(encoding, this.pos, this.pos + len);
-    this.pos += len;
-    return str;
-};
+        str = this.buffer.toString(encoding, this.pos, this.pos + len);
+        this.pos += len;
+        return str;
+    }
 
-BlrReader.prototype.readSegment = function() {
+    readSegment() {
+        var ret, tmp;
+        var len = this.buffer.readUInt16LE(this.pos);
 
-    var ret, tmp;
-    var len = this.buffer.readUInt16LE(this.pos);
+        this.pos += 2;
 
-    this.pos += 2;
+        while (len > 0) {
 
-    while (len > 0) {
+            if (ret) {
+                tmp = ret;
+                ret = Buffer.alloc(tmp.length + len);
+                tmp.copy(ret);
+                this.buffer.copy(ret, tmp.length, this.pos, this.pos + len);
+            } else {
+                ret = Buffer.alloc(len);
+                this.buffer.copy(ret, 0, this.pos, this.pos + len);
+            }
 
-        if (ret) {
-            tmp = ret;
-            ret = Buffer.alloc(tmp.length + len);
-            tmp.copy(ret);
-            this.buffer.copy(ret, tmp.length, this.pos, this.pos + len);
-        } else {
-            ret = Buffer.alloc(len);
-            this.buffer.copy(ret, 0, this.pos, this.pos + len);
-        }
+            this.pos += len;
 
-        this.pos += len;
+            if (this.pos === this.buffer.length)
+                break;
 
-        if (this.pos === this.buffer.length)
-            break;
+            len = this.buffer.readUInt16LE(this.pos);
+            this.pos += 2;
+        }
 
-        len = this.buffer.readUInt16LE(this.pos);
-        this.pos += 2;
+        return ret ? ret : Buffer.alloc(0);
     }
-
-    return ret ? ret : Buffer.alloc(0);
-};
+}
 
 /***************************************
  *
@@ -233,119 +247,121 @@ BlrReader.prototype.readSegment = function() {
  *
  ***************************************/
 
-var XdrWriter = exports.XdrWriter = function(size){
-    this.buffer = Buffer.alloc(size || 32);
-    this.pos = 0;
-};
-
-XdrWriter.prototype.ensure = BlrWriter.prototype.ensure = function (len) {
-    var newlen = this.buffer.length;
-
-    while (newlen < this.pos + len)
-        newlen *= 2
-
-    if (this.buffer.length >= newlen)
-        return;
-
-    var b = Buffer.alloc(newlen);
-    this.buffer.copy(b);
-    delete(this.buffer);
-    this.buffer = b;
-};
-
-XdrWriter.prototype.addInt = function (value) {
-    this.ensure(4);
-    this.buffer.writeInt32BE(value, this.pos);
-    this.pos += 4;
-};
-
-XdrWriter.prototype.addInt64 = function (value) {
-    this.ensure(8);
-    var l = Long.fromNumber(value);
-    this.buffer.writeInt32BE(l.high, this.pos);
-    this.pos += 4;
-    this.buffer.writeInt32BE(l.low, this.pos);
-    this.pos += 4;
-};
-
-XdrWriter.prototype.addInt128 = function (value) {
-    this.ensure(16);
-
-    const bigValue = BigInt(value);
-
-    const high = bigValue >> BigInt(64);
-    const low = bigValue & BigInt("0xFFFFFFFFFFFFFFFF");
-
-    this.buffer.writeBigUInt64BE(high, this.pos);
-    this.pos += 8;
-    this.buffer.writeBigUInt64BE(low, this.pos);
-    this.pos += 8;
-};
-
-XdrWriter.prototype.addUInt = function (value) {
-    this.ensure(4);
-    this.buffer.writeUInt32BE(value, this.pos);
-    this.pos += 4;
-};
-
-XdrWriter.prototype.addString = function(s, encoding) {
-    var len = Buffer.byteLength(s, encoding);
-    var alen = align(len);
-    this.ensure(alen + 4);
-    this.buffer.writeInt32BE(len, this.pos);
-    this.pos += 4;
-    this.buffer.write(s, this.pos, len, encoding);
-    this.pos += alen;
-};
-
-XdrWriter.prototype.addText = function(s, encoding) {
-    var len = Buffer.byteLength(s, encoding);
-    var alen = align(len);
-    this.ensure(alen);
-    this.buffer.write(s, this.pos, len, encoding);
-    this.pos += alen;
-};
-
-XdrWriter.prototype.addBlr = function(blr) {
-    var alen = align(blr.pos);
-    this.ensure(alen + 4);
-    this.buffer.writeInt32BE(blr.pos, this.pos);
-    this.pos += 4;
-    blr.buffer.copy(this.buffer, this.pos);
-    this.pos += alen;
-};
-
-XdrWriter.prototype.getData = function() {
-    return this.buffer.slice(0, this.pos);
-};
-
-XdrWriter.prototype.addDouble = function(value) {
-    this.ensure(8);
-    this.buffer.writeDoubleBE(value, this.pos);
-    this.pos += 8;
-};
-
-XdrWriter.prototype.addQuad = function(quad) {
-    this.ensure(8);
-    var b = this.buffer;
-    b.writeInt32BE(quad.high, this.pos);
-    this.pos += 4;
-    b.writeInt32BE(quad.low, this.pos);
-    this.pos += 4;
-};
-
-XdrWriter.prototype.addBuffer = function(buffer) {
-    this.ensure(buffer.length);
-    buffer.copy(this.buffer, this.pos, 0, buffer.length);
-    this.pos += buffer.length;
-}
+class XdrWriter {
+    constructor(size) {
+        this.buffer = Buffer.alloc(size || 32);
+        this.pos = 0;
+    }
+
+    ensure(len) {
+        var newlen = this.buffer.length;
+
+        while (newlen < this.pos + len)
+            newlen *= 2
+
+        if (this.buffer.length >= newlen)
+            return;
+
+        var b = Buffer.alloc(newlen);
+        this.buffer.copy(b);
+        delete(this.buffer);
+        this.buffer = b;
+    }
+
+    addInt(value) {
+        this.ensure(4);
+        this.buffer.writeInt32BE(value, this.pos);
+        this.pos += 4;
+    }
+
+    addInt64(value) {
+        this.ensure(8);
+        var l = Long.fromNumber(value);
+        this.buffer.writeInt32BE(l.high, this.pos);
+        this.pos += 4;
+        this.buffer.writeInt32BE(l.low, this.pos);
+        this.pos += 4;
+    }
 
-XdrWriter.prototype.addAlignment = function(len) {
-    var alen = (4 - len) & 3;
+    addInt128(value) {
+        this.ensure(16);
 
-    this.ensure(alen);
-    this.buffer.write('ffffff', this.pos, alen, 'hex');
-    this.pos += alen;
+        const bigValue = BigInt(value);
+
+        const high = bigValue >> BigInt(64);
+        const low = bigValue & BigInt("0xFFFFFFFFFFFFFFFF");
+
+        this.buffer.writeBigUInt64BE(high, this.pos);
+        this.pos += 8;
+        this.buffer.writeBigUInt64BE(low, this.pos);
+        this.pos += 8;
+    }
+
+    addUInt(value) {
+        this.ensure(4);
+        this.buffer.writeUInt32BE(value, this.pos);
+        this.pos += 4;
+    }
+
+    addString(s, encoding) {
+        var len = Buffer.byteLength(s, encoding);
+        var alen = align(len);
+        this.ensure(alen + 4);
+        this.buffer.writeInt32BE(len, this.pos);
+        this.pos += 4;
+        this.buffer.write(s, this.pos, len, encoding);
+        this.pos += alen;
+    }
+
+    addText(s, encoding) {
+        var len = Buffer.byteLength(s, encoding);
+        var alen = align(len);
+        this.ensure(alen);
+        this.buffer.write(s, this.pos, len, encoding);
+        this.pos += alen;
+    }
+
+    addBlr(blr) {
+        var alen = align(blr.pos);
+        this.ensure(alen + 4);
+        this.buffer.writeInt32BE(blr.pos, this.pos);
+        this.pos += 4;
+        blr.buffer.copy(this.buffer, this.pos);
+        this.pos += alen;
+    }
+
+    getData() {
+        return this.buffer.slice(0, this.pos);
+    }
+
+    addDouble(value) {
+        this.ensure(8);
+        this.buffer.writeDoubleBE(value, this.pos);
+        this.pos += 8;
+    }
+
+    addQuad(quad) {
+        this.ensure(8);
+        var b = this.buffer;
+        b.writeInt32BE(quad.high, this.pos);
+        this.pos += 4;
+        b.writeInt32BE(quad.low, this.pos);
+        this.pos += 4;
+    }
+
+    addBuffer(buffer) {
+        this.ensure(buffer.length);
+        buffer.copy(this.buffer, this.pos, 0, buffer.length);
+        this.pos += buffer.length;
+    }
+
+    addAlignment(len) {
+        var alen = (4 - len) & 3;
+
+        this.ensure(alen);
+        this.buffer.write('ffffff', this.pos, alen, 'hex');
+        this.pos += alen;
+    }
 }
 
 /***************************************
@@ -354,107 +370,109 @@ XdrWriter.prototype.addAlignment = function(len) {
  *
  ***************************************/
 
-var XdrReader = exports.XdrReader = function(buffer){
-    this.buffer = buffer;
-    this.pos = 0;
-};
-
-XdrReader.prototype.readInt = function () {
-    var r = this.buffer.readInt32BE(this.pos);
-    this.pos += 4;
-    return r;
-};
-
-XdrReader.prototype.readUInt = function () {
-    var r = this.buffer.readUInt32BE(this.pos);
-    this.pos += 4;
-    return r;
-};
-
-XdrReader.prototype.readInt64 = function () {
-    var high = this.buffer.readInt32BE(this.pos);
-    this.pos += 4;
-    var low = this.buffer.readInt32BE(this.pos);
-    this.pos += 4;
-    return new Long(low, high).toNumber();
-};
-
-XdrReader.prototype.readInt128 = function () {
-    var high = this.buffer.readBigUInt64BE(this.pos)
-    this.pos += 8
-
-    var low = this.buffer.readBigUInt64BE(this.pos)
-    this.pos += 8
-
-    return (BigInt(high) << BigInt(64)) + BigInt(low)
-};
-
-XdrReader.prototype.readShort = function () {
-    var r = this.buffer.readInt16BE(this.pos);
-    this.pos += 2;
-    return r;
-};
-
-XdrReader.prototype.readQuad = function () {
-    var b = this.buffer;
-    var high = b.readInt32BE(this.pos);
-    this.pos += 4;
-    var low = b.readInt32BE(this.pos);
-    this.pos += 4;
-    return {low: low, high: high}
-};
-
-XdrReader.prototype.readFloat = function () {
-    var r = this.buffer.readFloatBE(this.pos);
-    this.pos += 4;
-    return r;
-};
-
-XdrReader.prototype.readDouble = function () {
-    var r = this.buffer.readDoubleBE(this.pos);
-    this.pos += 8;
-    return r;
-};
-
-XdrReader.prototype.readArray = function () {
-    var len = this.readInt();
-    if (!len)
-        return;
-    var r = this.buffer.slice(this.pos, this.pos + len);
-    this.pos += align(len);
-    return r;
-};
-
-XdrReader.prototype.readBuffer = function (len, toAlign = true) {
-    if (!arguments.length) {
-        len = this.readInt();
-    }
-
-    if (len !== null && len !== undefined) {
-
-        if (len <= 0){
-            return Buffer.alloc(0);
-        }
+class XdrReader {
+    constructor(buffer) {
+        this.buffer = buffer;
+        this.pos = 0;
+    }
+
+    readInt() {
+        var r = this.buffer.readInt32BE(this.pos);
+        this.pos += 4;
+        return r;
+    }
 
+    readUInt() {
+        var r = this.buffer.readUInt32BE(this.pos);
+        this.pos += 4;
+        return r;
+    }
+
+    readInt64() {
+        var high = this.buffer.readInt32BE(this.pos);
+        this.pos += 4;
+        var low = this.buffer.readInt32BE(this.pos);
+        this.pos += 4;
+        return new Long(low, high).toNumber();
+    }
+
+    readInt128() {
+        var high = this.buffer.readBigUInt64BE(this.pos)
+        this.pos += 8
+
+        var low = this.buffer.readBigUInt64BE(this.pos)
+        this.pos += 8
+
+        return (BigInt(high) << BigInt(64)) + BigInt(low)
+    }
+
+    readShort() {
+        var r = this.buffer.readInt16BE(this.pos);
+        this.pos += 2;
+        return r;
+    }
+
+    readQuad() {
+        var b = this.buffer;
+        var high = b.readInt32BE(this.pos);
+        this.pos += 4;
+        var low = b.readInt32BE(this.pos);
+        this.pos += 4;
+        return {low: low, high: high}
+    }
+
+    readFloat() {
+        var r = this.buffer.readFloatBE(this.pos);
+        this.pos += 4;
+        return r;
+    }
+
+    readDouble() {
+        var r = this.buffer.readDoubleBE(this.pos);
+        this.pos += 8;
+        return r;
+    }
+
+    readArray() {
+        var len = this.readInt();
+        if (!len)
+            return;
         var r = this.buffer.slice(this.pos, this.pos + len);
-        this.pos += toAlign ? align(len) : len;
+        this.pos += align(len);
         return r;
     }
-};
 
-XdrReader.prototype.readString = function(encoding) {
-    var len = this.readInt();
-    return this.readText(len, encoding);
-};
+    readBuffer(len, toAlign = true) {
+        if (!arguments.length) {
+            len = this.readInt();
+        }
+
+        if (len !== null && len !== undefined) {
+
+            if (len <= 0){
+                return Buffer.alloc(0);
+            }
+
+            var r = this.buffer.slice(this.pos, this.pos + len);
+            this.pos += toAlign ? align(len) : len;
+            return r;
+        }
+    }
+
+    readString(encoding) {
+        var len = this.readInt();
+        return this.readText(len, encoding);
+    }
 
-XdrReader.prototype.readText = function(len, encoding) {
-    if (len <= 0)
-        return '';
+    readText(len, encoding) {
+        if (len <= 0)
+            return '';
 
-    var r = this.buffer.toString(encoding, this.pos, this.pos + len);
-    this.pos += align(len);
-    return r;
-};
+        var r = this.buffer.toString(encoding, this.pos, this.pos + len);
+        this.pos += align(len);
+        return r;
+    }
+}
 
 /***************************************
  *
@@ -466,57 +484,65 @@ var BUFFER_BITS = 8;
 var BIT_ON = 1;
 var BIT_OFF = 0;
 
-var BitSet = exports.BitSet = function(buffer) {
-    this.data = [];
+class BitSet {
+    constructor(buffer) {
+        this.data = [];
 
-    if (buffer) {
-        this.scale(buffer.length * BUFFER_BITS);
+        if (buffer) {
+            this.scale(buffer.length * BUFFER_BITS);
 
-        for (var i = 0; i < buffer.length; i++) {
-            var n = buffer[i];
+            for (var i = 0; i < buffer.length; i++) {
+                var n = buffer[i];
 
-            for (var j = 0; j < BUFFER_BITS; j++) {
-                var k = i * BUFFER_BITS + j;
-                this.data[k >>> WORD_LOG] |= (n >> j & BIT_ON) << k;
+                for (var j = 0; j < BUFFER_BITS; j++) {
+                    var k = i * BUFFER_BITS + j;
+                    this.data[k >>> WORD_LOG] |= (n >> j & BIT_ON) << k;
+                }
             }
         }
     }
-};
 
-BitSet.prototype.scale = function(index) {
-    var l = index >>> WORD_LOG;
+    scale(index) {
+        var l = index >>> WORD_LOG;
 
-    for (var i = this.data.length; l >= i; l--) {
-        this.data.push(BIT_OFF);
+        for (var i = this.data.length; l >= i; l--) {
+            this.data.push(BIT_OFF);
+        }
     }
-};
 
-BitSet.prototype.set = function(index, value) {
-    let pos = index >>> 3;
+    set(index, value) {
+        let pos = index >>> 3;
 
-    for (let i = this.data.length; pos >= i; pos--) {
-        this.data.push(BIT_OFF);
-    }
+        for (let i = this.data.length; pos >= i; pos--) {
+            this.data.push(BIT_OFF);
+        }
 
-    pos = index >>> 3;
+        pos = index >>> 3;
 
-    if (value === undefined || value) {
-        this.data[pos] |= (1 << (index % BUFFER_BITS));
-    } else {
-        this.data[pos] &= ~(1 << (index % BUFFER_BITS));
+        if (value === undefined || value) {
+            this.data[pos] |= (1 << (index % BUFFER_BITS));
+        } else {
+            this.data[pos] &= ~(1 << (index % BUFFER_BITS));
+        }
     }
-};
 
-BitSet.prototype.get = function(index) {
-    var n = index >>> WORD_LOG;
+    get(index) {
+        var n = index >>> WORD_LOG;
 
-    if (n >= this.data.length) {
-        return BIT_OFF;
+        if (n >= this.data.length) {
+            return BIT_OFF;
+        }
+
+        return (this.data[n] >>> index) & BIT_ON;
     }
 
-    return (this.data[n] >>> index) & BIT_ON;
-};
+    toBuffer() {
+        return Buffer.from(this.data);
+    }
+}
 
-BitSet.prototype.toBuffer = function() {
-    return Buffer.from(this.data);
-};
+exports.BlrWriter = BlrWriter;
+exports.BlrReader = BlrReader;
+exports.XdrWriter = XdrWriter;
+exports.XdrReader = XdrReader;
+exports.BitSet = BitSet;