@woosh/meep-engine 2.39.31 → 2.39.34

package/core/binary/BinaryBuffer.js

@@ -21,1076 +21,1074 @@ export const EndianType = {
 const MIN_GROWTH_STEP = 1024;
 
 /**
- *
- * @constructor
+ * 2^31-1, values above this will be cropped incorrectly when bit-shifting
+ * @type {number}
  */
-function BinaryBuffer() {
-    /**
-     *
-     * @type {EndianType|boolean}
-     */
-    this.endianness = EndianType.BigEndian;
-
-    /**
-     *
-     * @type {number}
-     */
-    this.position = 0;
-
-    /**
-     *
-     * @type {number}
-     */
-    this.length = 0;
+const MAX_SAFE_UINT_VAR = 2147483647;
 
+export class BinaryBuffer {
     /**
      *
-     * @type {number}
+     * @constructor
      */
-    this.capacity = 0;
+    constructor() {
+        /**
+         *
+         * @type {EndianType|boolean}
+         */
+        this.endianness = EndianType.BigEndian;
+
+        /**
+         *
+         * @type {number}
+         */
+        this.position = 0;
+
+        /**
+         *
+         * @type {number}
+         */
+        this.length = 0;
+
+        /**
+         *
+         * @type {number}
+         */
+        this.capacity = 0;
+
+        /**
+         *
+         * @type {ArrayBuffer}
+         * @private
+         */
+        this.data = new ArrayBuffer(0);
+
+        /**
+         *
+         * @type {DataView}
+         * @private
+         */
+        this.dataView = new DataView(this.data);
+
+        /**
+         *
+         * @type {Uint8Array}
+         * @private
+         */
+        this.__data_uint8 = new Uint8Array(0);
+
+        /**
+         *
+         * @type {number}
+         * @private
+         */
+        this.__growFactor = 1.1;
+    }
 
     /**
-     *
-     * @type {ArrayBuffer}
-     * @private
+     * @param {ArrayBuffer} arrayBuffer
      */
-    this.data = new ArrayBuffer(0);
+    fromArrayBuffer(arrayBuffer) {
+        this.data = arrayBuffer;
+        this.dataView = new DataView(arrayBuffer);
+        this.__data_uint8 = new Uint8Array(arrayBuffer);
+
+        this.capacity = arrayBuffer.byteLength;
+        //assume that all the data is useful
+        this.length = this.capacity;
+        this.position = 0;
+    }
 
     /**
      *
-     * @type {DataView}
-     * @private
+     * @returns {BinaryBuffer}
      */
-    this.dataView = new DataView(this.data);
+    trim() {
+        this.setCapacity(this.position);
 
-    /**
-     *
-     * @type {Uint8Array}
-     * @private
-     */
-    this.__data_uint8 = new Uint8Array(0);
+        return this;
+    }
 
     /**
      *
-     * @type {number}
-     * @private
+     * @param {number} capacity
      */
-    this.__growFactor = 1.1;
-}
+    setCapacity(capacity) {
+        const oldData = this.__data_uint8;
+        const newData = new Uint8Array(capacity);
 
-/**
- * @param {ArrayBuffer} arrayBuffer
- */
-BinaryBuffer.prototype.fromArrayBuffer = function (arrayBuffer) {
-    this.data = arrayBuffer;
-    this.dataView = new DataView(arrayBuffer);
-    this.__data_uint8 = new Uint8Array(arrayBuffer);
-
-    this.capacity = arrayBuffer.byteLength;
-    //assume that all the data is useful
-    this.length = this.capacity;
-    this.position = 0;
-};
+        //copy old data
+        const copyLength = Math.min(newData.length, oldData.length);
+        newData.set(oldData.subarray(0, copyLength), 0);
 
-/**
- *
- * @param {ArrayBuffer} v
- * @return {BinaryBuffer}
- */
-BinaryBuffer.fromArrayBuffer = function (v) {
-    const r = new BinaryBuffer();
-
-    r.fromArrayBuffer(v);
-
-    return r;
-};
+        this.data = newData.buffer;
+        this.__data_uint8 = newData;
+        this.dataView = new DataView(this.data);
 
-/**
- *
- * @returns {BinaryBuffer}
- */
-BinaryBuffer.prototype.trim = function () {
-    this.setCapacity(this.position);
-
-    return this;
-};
-
-/**
- *
- * @param {number} capacity
- */
-BinaryBuffer.prototype.setCapacity = function (capacity) {
-    const oldData = this.__data_uint8;
-    const newData = new Uint8Array(capacity);
-
-    //copy old data
-    const copyLength = Math.min(newData.length, oldData.length);
-    newData.set(oldData.subarray(0, copyLength), 0);
-
-    this.data = newData.buffer;
-    this.__data_uint8 = newData;
-    this.dataView = new DataView(this.data);
-
-    this.capacity = capacity;
-};
-
-BinaryBuffer.prototype.ensureCapacity = function (minCapacity) {
-    if (this.capacity < minCapacity) {
-        const newCapacity = Math.ceil(Math.max(
-            minCapacity,
-            this.capacity * this.__growFactor,
-            this.capacity + MIN_GROWTH_STEP
-        ));
-        this.setCapacity(newCapacity);
+        this.capacity = capacity;
     }
-};
 
-BinaryBuffer.prototype.readFloat32 = function () {
-    const result = this.dataView.getFloat32(this.position, this.endianness);
+    ensureCapacity(minCapacity) {
+        if (this.capacity < minCapacity) {
+            const newCapacity = Math.ceil(Math.max(
+                minCapacity,
+                this.capacity * this.__growFactor,
+                this.capacity + MIN_GROWTH_STEP
+            ));
+            this.setCapacity(newCapacity);
+        }
+    }
 
-    this.position += 4;
+    readFloat32() {
+        const result = this.dataView.getFloat32(this.position, this.endianness);
 
-    return result;
-};
+        this.position += 4;
 
-BinaryBuffer.prototype.readFloat64 = function () {
-    const result = this.dataView.getFloat64(this.position, this.endianness);
+        return result;
+    }
 
-    this.position += 8;
+    readFloat64() {
+        const result = this.dataView.getFloat64(this.position, this.endianness);
 
-    return result;
-};
+        this.position += 8;
 
-BinaryBuffer.prototype.readInt8 = function () {
-    const result = this.dataView.getInt8(this.position);
+        return result;
+    }
 
-    this.position += 1;
+    readInt8() {
+        const result = this.dataView.getInt8(this.position);
 
-    return result;
-};
+        this.position += 1;
 
-BinaryBuffer.prototype.readInt16 = function () {
-    const result = this.dataView.getInt16(this.position, this.endianness);
+        return result;
+    }
 
-    this.position += 2;
+    readInt16() {
+        const result = this.dataView.getInt16(this.position, this.endianness);
 
-    return result;
-};
+        this.position += 2;
 
-/**
- *
- * @returns {number}
- */
-BinaryBuffer.prototype.readInt32 = function () {
-    const result = this.dataView.getInt32(this.position, this.endianness);
+        return result;
+    }
 
-    this.position += 4;
+    /**
+     *
+     * @returns {number}
+     */
+    readInt32() {
+        const result = this.dataView.getInt32(this.position, this.endianness);
 
-    return result;
-};
+        this.position += 4;
 
-/**
- *
- * @returns {number}
- */
-BinaryBuffer.prototype.readUint8 = function () {
-    const result = this.dataView.getUint8(this.position);
+        return result;
+    }
 
-    this.position += 1;
+    /**
+     *
+     * @returns {number}
+     */
+    readUint8() {
+        const result = this.dataView.getUint8(this.position);
 
-    return result;
-};
+        this.position += 1;
 
-/**
- *
- * @returns {number}
- */
-BinaryBuffer.prototype.readUint16 = function () {
-    const result = this.dataView.getUint16(this.position, this.endianness);
+        return result;
+    }
 
-    this.position += 2;
+    /**
+     *
+     * @returns {number}
+     */
+    readUint16() {
+        const result = this.dataView.getUint16(this.position, this.endianness);
 
-    return result;
-};
+        this.position += 2;
 
-/**
- *
- * @returns {number}
- */
-BinaryBuffer.prototype.readUint16LE = function () {
-    const result = this.dataView.getUint16(this.position, EndianType.LittleEndian);
+        return result;
+    }
 
-    this.position += 2;
+    /**
+     *
+     * @returns {number}
+     */
+    readUint16LE() {
+        const result = this.dataView.getUint16(this.position, EndianType.LittleEndian);
 
-    return result;
-};
+        this.position += 2;
 
-/**
- *
- * @returns {number}
- */
-BinaryBuffer.prototype.readUint16BE = function () {
-    const result = this.dataView.getUint16(this.position, EndianType.BigEndian);
+        return result;
+    }
 
-    this.position += 2;
+    /**
+     *
+     * @returns {number}
+     */
+    readUint16BE() {
+        const result = this.dataView.getUint16(this.position, EndianType.BigEndian);
 
-    return result;
-};
+        this.position += 2;
 
-/**
- *
- * @returns {number}
- */
-BinaryBuffer.prototype.readUint24 = function () {
-    if (this.endianness === EndianType.BigEndian) {
-        return this.readUint24BE();
-    } else {
-        return this.readUint24LE();
+        return result;
     }
-};
 
-/**
- *
- * @returns {number}
- */
-BinaryBuffer.prototype.readUint24LE = function () {
-    const b0 = this.dataView.getUint8(this.position);
-    const b1 = this.dataView.getUint8(this.position + 1);
-    const b2 = this.dataView.getUint8(this.position + 2);
+    /**
+     *
+     * @returns {number}
+     */
+    readUint24() {
+        if (this.endianness === EndianType.BigEndian) {
+            return this.readUint24BE();
+        } else {
+            return this.readUint24LE();
+        }
+    }
 
-    this.position += 3;
+    /**
+     *
+     * @returns {number}
+     */
+    readUint24LE() {
+        const b0 = this.dataView.getUint8(this.position);
+        const b1 = this.dataView.getUint8(this.position + 1);
+        const b2 = this.dataView.getUint8(this.position + 2);
 
-    return b0 | (b1 << 8) | (b2 << 16);
-};
+        this.position += 3;
 
-/**
- *
- * @returns {number}
- */
-BinaryBuffer.prototype.readUint24BE = function () {
-    const b0 = this.dataView.getUint8(this.position);
-    const b1 = this.dataView.getUint8(this.position + 1);
-    const b2 = this.dataView.getUint8(this.position + 2);
+        return b0 | (b1 << 8) | (b2 << 16);
+    }
 
-    this.position += 3;
+    /**
+     *
+     * @returns {number}
+     */
+    readUint24BE() {
+        const b0 = this.dataView.getUint8(this.position);
+        const b1 = this.dataView.getUint8(this.position + 1);
+        const b2 = this.dataView.getUint8(this.position + 2);
 
-    return b2 | (b1 << 8) | (b0 << 16);
-};
+        this.position += 3;
 
-/**
- *
- * @returns {number}
- */
-BinaryBuffer.prototype.readUint32 = function () {
-    const result = this.dataView.getUint32(this.position, this.endianness);
+        return b2 | (b1 << 8) | (b0 << 16);
+    }
 
-    this.position += 4;
+    /**
+     *
+     * @returns {number}
+     */
+    readUint32() {
+        const result = this.dataView.getUint32(this.position, this.endianness);
 
-    return result;
-};
+        this.position += 4;
 
-/**
- *
- * @returns {number}
- */
-BinaryBuffer.prototype.readUint32LE = function () {
-    const result = this.dataView.getUint32(this.position, EndianType.LittleEndian);
+        return result;
+    }
 
-    this.position += 4;
+    /**
+     *
+     * @returns {number}
+     */
+    readUint32LE() {
+        const result = this.dataView.getUint32(this.position, EndianType.LittleEndian);
 
-    return result;
-};
+        this.position += 4;
 
-/**
- *
- * @returns {number}
- */
-BinaryBuffer.prototype.readUint32BE = function () {
-    const result = this.dataView.getUint32(this.position, EndianType.BigEndian);
+        return result;
+    }
 
-    this.position += 4;
+    /**
+     *
+     * @returns {number}
+     */
+    readUint32BE() {
+        const result = this.dataView.getUint32(this.position, EndianType.BigEndian);
 
-    return result;
-};
+        this.position += 4;
 
-/**
- *
- * @param {number} destination_offset starting index in the destination array
- * @param {number} length number of elements to read
- * @param {Uint8Array} destination
- */
-BinaryBuffer.prototype.readUint8Array = function (destination, destination_offset, length) {
-    for (let i = 0; i < length; i++) {
-        destination[i + destination_offset] = this.readUint8();
+        return result;
     }
-};
 
-/**
- *
- * @param {number} destination_offset starting index in the destination array
- * @param {number} length number of elements to read
- * @param {Uint16Array} destination
- */
-BinaryBuffer.prototype.readUint16Array = function (destination, destination_offset, length) {
-    for (let i = 0; i < length; i++) {
-        destination[i + destination_offset] = this.readUint16();
+    /**
+     *
+     * @param {number} destination_offset starting index in the destination array
+     * @param {number} length number of elements to read
+     * @param {Uint8Array} destination
+     */
+    readUint8Array(destination, destination_offset, length) {
+        for (let i = 0; i < length; i++) {
+            destination[i + destination_offset] = this.readUint8();
+        }
     }
-};
 
-/**
- *
- * @param {number} destination_offset starting index in the destination array
- * @param {number} length number of elements to read
- * @param {Uint32Array} destination
- */
-BinaryBuffer.prototype.readUint32Array = function (destination, destination_offset, length) {
-    for (let i = 0; i < length; i++) {
-        destination[i + destination_offset] = this.readUint32();
+    /**
+     *
+     * @param {number} destination_offset starting index in the destination array
+     * @param {number} length number of elements to read
+     * @param {Uint16Array} destination
+     */
+    readUint16Array(destination, destination_offset, length) {
+        for (let i = 0; i < length; i++) {
+            destination[i + destination_offset] = this.readUint16();
+        }
     }
-};
 
-/**
- *
- * @param {number} destination_offset starting index in the destination array
- * @param {number} length number of elements to read
- * @param {Int8Array} destination
- */
-BinaryBuffer.prototype.readInt8Array = function (destination, destination_offset, length) {
-    for (let i = 0; i < length; i++) {
-        destination[i + destination_offset] = this.readInt8();
+    /**
+     *
+     * @param {number} destination_offset starting index in the destination array
+     * @param {number} length number of elements to read
+     * @param {Uint32Array} destination
+     */
+    readUint32Array(destination, destination_offset, length) {
+        for (let i = 0; i < length; i++) {
+            destination[i + destination_offset] = this.readUint32();
+        }
     }
-};
 
-/**
- *
- * @param {number} destination_offset starting index in the destination array
- * @param {number} length number of elements to read
- * @param {Int16Array} destination
- */
-BinaryBuffer.prototype.readInt16Array = function (destination, destination_offset, length) {
-    for (let i = 0; i < length; i++) {
-        destination[i + destination_offset] = this.readInt16();
+    /**
+     *
+     * @param {number} destination_offset starting index in the destination array
+     * @param {number} length number of elements to read
+     * @param {Int8Array} destination
+     */
+    readInt8Array(destination, destination_offset, length) {
+        for (let i = 0; i < length; i++) {
+            destination[i + destination_offset] = this.readInt8();
+        }
     }
-};
 
-/**
- *
- * @param {number} destination_offset starting index in the destination array
- * @param {number} length number of elements to read
- * @param {Int32Array} destination
- */
-BinaryBuffer.prototype.readInt32Array = function (destination, destination_offset, length) {
-    for (let i = 0; i < length; i++) {
-        destination[i + destination_offset] = this.readInt32();
+    /**
+     *
+     * @param {number} destination_offset starting index in the destination array
+     * @param {number} length number of elements to read
+     * @param {Int16Array} destination
+     */
+    readInt16Array(destination, destination_offset, length) {
+        for (let i = 0; i < length; i++) {
+            destination[i + destination_offset] = this.readInt16();
+        }
     }
-};
 
+    /**
+     *
+     * @param {number} destination_offset starting index in the destination array
+     * @param {number} length number of elements to read
+     * @param {Int32Array} destination
+     */
+    readInt32Array(destination, destination_offset, length) {
+        for (let i = 0; i < length; i++) {
+            destination[i + destination_offset] = this.readInt32();
+        }
+    }
 
-/**
- *
- * @param {number} destination_offset starting index in the destination array
- * @param {number} length number of elements to read
- * @param {Float32Array|number[]} destination
- */
-BinaryBuffer.prototype.readFloat32Array = function (destination, destination_offset, length) {
-    for (let i = 0; i < length; i++) {
-        destination[i + destination_offset] = this.readFloat32();
+    /**
+     *
+     * @param {number} destination_offset starting index in the destination array
+     * @param {number} length number of elements to read
+     * @param {Float32Array|number[]} destination
+     */
+    readFloat32Array(destination, destination_offset, length) {
+        for (let i = 0; i < length; i++) {
+            destination[i + destination_offset] = this.readFloat32();
+        }
     }
-};
 
-/**
- *
- * @param {number} destination_offset starting index in the destination array
- * @param {number} length number of elements to read
- * @param {Float64Array} destination
- */
-BinaryBuffer.prototype.readFloat64Array = function (destination, destination_offset, length) {
-    for (let i = 0; i < length; i++) {
-        destination[i + destination_offset] = this.readFloat64();
+    /**
+     *
+     * @param {number} destination_offset starting index in the destination array
+     * @param {number} length number of elements to read
+     * @param {Float64Array} destination
+     */
+    readFloat64Array(destination, destination_offset, length) {
+        for (let i = 0; i < length; i++) {
+            destination[i + destination_offset] = this.readFloat64();
+        }
     }
-};
 
-/**
- *
- * @param {number} source_offset starting index in the source array
- * @param {number} length number of elements to read
- * @param {Float32Array|number[]} source
- */
-BinaryBuffer.prototype.writeFloat32Array = function (source, source_offset, length) {
-    for (let i = 0; i < length; i++) {
-        this.writeFloat32(source[i + source_offset]);
+    /**
+     *
+     * @param {number} source_offset starting index in the source array
+     * @param {number} length number of elements to read
+     * @param {Float32Array|number[]} source
+     */
+    writeFloat32Array(source, source_offset, length) {
+        for (let i = 0; i < length; i++) {
+            this.writeFloat32(source[i + source_offset]);
+        }
     }
-};
 
-/**
- *
- * @param {number} value
- */
-BinaryBuffer.prototype.writeFloat32 = function (value) {
-    const end = this.position + 4;
-    this.ensureCapacity(end);
+    /**
+     *
+     * @param {number} value
+     */
+    writeFloat32(value) {
+        const end = this.position + 4;
+        this.ensureCapacity(end);
 
-    this.dataView.setFloat32(this.position, value, this.endianness);
+        this.dataView.setFloat32(this.position, value, this.endianness);
 
-    this.position = end;
-};
+        this.position = end;
+    }
 
-/**
- *
- * @param {number} value
- */
-BinaryBuffer.prototype.writeFloat64 = function (value) {
-    const end = this.position + 8;
-    this.ensureCapacity(end);
+    /**
+     *
+     * @param {number} value
+     */
+    writeFloat64(value) {
+        const end = this.position + 8;
+        this.ensureCapacity(end);
 
-    this.dataView.setFloat64(this.position, value, this.endianness);
+        this.dataView.setFloat64(this.position, value, this.endianness);
 
-    this.position = end;
-};
+        this.position = end;
+    }
 
-/**
- *
- * @param {number} value
- */
-BinaryBuffer.prototype.writeInt8 = function (value) {
-    const end = this.position + 1;
-    this.ensureCapacity(end);
+    /**
+     *
+     * @param {number} value
+     */
+    writeInt8(value) {
+        const end = this.position + 1;
+        this.ensureCapacity(end);
 
-    this.dataView.setInt8(this.position, value);
+        this.dataView.setInt8(this.position, value);
 
-    this.position = end;
-};
+        this.position = end;
+    }
 
-/**
- *
- * @param {number} value
- */
-BinaryBuffer.prototype.writeInt16 = function (value) {
-    const end = this.position + 2;
-    this.ensureCapacity(end);
+    /**
+     *
+     * @param {number} value
+     */
+    writeInt16(value) {
+        const end = this.position + 2;
+        this.ensureCapacity(end);
 
-    this.dataView.setInt16(this.position, value, this.endianness);
+        this.dataView.setInt16(this.position, value, this.endianness);
 
-    this.position = end;
-};
+        this.position = end;
+    }
 
-/**
- *
- * @param {number} value
- */
-BinaryBuffer.prototype.writeInt32 = function (value) {
-    const end = this.position + 4;
-    this.ensureCapacity(end);
+    /**
+     *
+     * @param {number} value
+     */
+    writeInt32(value) {
+        const end = this.position + 4;
+        this.ensureCapacity(end);
 
-    this.dataView.setInt32(this.position, value, this.endianness);
+        this.dataView.setInt32(this.position, value, this.endianness);
 
-    this.position = end;
-};
+        this.position = end;
+    }
 
-/**
- *
- * @param {number} value
- */
-BinaryBuffer.prototype.writeUint8 = function (value) {
-    const end = this.position + 1;
-    this.ensureCapacity(end);
+    /**
+     *
+     * @param {number} value
+     */
+    writeUint8(value) {
+        const end = this.position + 1;
+        this.ensureCapacity(end);
 
-    this.dataView.setUint8(this.position, value);
+        this.dataView.setUint8(this.position, value);
 
-    this.position = end;
-};
+        this.position = end;
+    }
 
-/**
- *
- * @param {Uint8Array|number[]} source
- * @param {number} source_offset
- * @param {number} length
- */
-BinaryBuffer.prototype.writeUint8Array = function (source, source_offset, length) {
-    for (let i = 0; i < length; i++) {
-        this.writeUint8(source[source_offset + i]);
+    /**
+     *
+     * @param {Uint8Array|number[]} source
+     * @param {number} source_offset
+     * @param {number} length
+     */
+    writeUint8Array(source, source_offset, length) {
+        for (let i = 0; i < length; i++) {
+            this.writeUint8(source[source_offset + i]);
+        }
     }
-}
 
-/**
- *
- * @param {number} value
- */
-BinaryBuffer.prototype.writeUint16 = function (value) {
-    const end = this.position + 2;
-    this.ensureCapacity(end);
+    /**
+     *
+     * @param {number} value
+     */
+    writeUint16(value) {
+        const end = this.position + 2;
+        this.ensureCapacity(end);
 
-    this.dataView.setUint16(this.position, value, this.endianness);
+        this.dataView.setUint16(this.position, value, this.endianness);
 
-    this.position = end;
-};
+        this.position = end;
+    }
 
-/**
- *
- * @param {number} value
- */
-BinaryBuffer.prototype.writeUint16BE = function (value) {
-    const end = this.position + 2;
-    this.ensureCapacity(end);
+    /**
+     *
+     * @param {number} value
+     */
+    writeUint16BE(value) {
+        const end = this.position + 2;
+        this.ensureCapacity(end);
 
-    this.dataView.setUint16(this.position, value, EndianType.BigEndian);
+        this.dataView.setUint16(this.position, value, EndianType.BigEndian);
 
-    this.position = end;
-};
+        this.position = end;
+    }
 
-/**
- *
- * @param {number} value
- */
-BinaryBuffer.prototype.writeUint16LE = function (value) {
-    const end = this.position + 2;
-    this.ensureCapacity(end);
+    /**
+     *
+     * @param {number} value
+     */
+    writeUint16LE(value) {
+        const end = this.position + 2;
+        this.ensureCapacity(end);
 
-    this.dataView.setUint16(this.position, value, EndianType.LittleEndian);
+        this.dataView.setUint16(this.position, value, EndianType.LittleEndian);
 
-    this.position = end;
-};
+        this.position = end;
+    }
 
-/**
- *
- * @param {Uint16Array|number[]} source
- * @param {number} source_offset
- * @param {number} length
- */
-BinaryBuffer.prototype.writeUint16Array = function (source, source_offset, length) {
-    for (let i = 0; i < length; i++) {
-        this.writeUint16(source[source_offset + i]);
+    /**
+     *
+     * @param {Uint16Array|number[]} source
+     * @param {number} source_offset
+     * @param {number} length
+     */
+    writeUint16Array(source, source_offset, length) {
+        for (let i = 0; i < length; i++) {
+            this.writeUint16(source[source_offset + i]);
+        }
     }
-}
 
-/**
- *
- * @param {number} value
- */
-BinaryBuffer.prototype.writeUint24 = function (value) {
-    if (this.endianness === EndianType.BigEndian) {
-        this.writeUint24BE(value);
-    } else {
-        this.writeUint24LE(value);
+    /**
+     *
+     * @param {number} value
+     */
+    writeUint24(value) {
+        if (this.endianness === EndianType.BigEndian) {
+            this.writeUint24BE(value);
+        } else {
+            this.writeUint24LE(value);
+        }
     }
-};
 
-/**
- *
- * @param {number} value
- */
-BinaryBuffer.prototype.writeUint24BE = function (value) {
-    const end = this.position + 3;
+    /**
+     *
+     * @param {number} value
+     */
+    writeUint24BE(value) {
+        const end = this.position + 3;
 
-    this.ensureCapacity(end);
+        this.ensureCapacity(end);
 
-    const b0 = value & 0xFF;
-    const b1 = (value >> 8) & 0xFF;
-    const b2 = (value >> 16) & 0xFF;
+        const b0 = value & 0xFF;
+        const b1 = (value >> 8) & 0xFF;
+        const b2 = (value >> 16) & 0xFF;
 
-    this.dataView.setUint8(this.position, b2);
-    this.dataView.setUint8(this.position + 1, b1);
-    this.dataView.setUint8(this.position + 2, b0);
+        this.dataView.setUint8(this.position, b2);
+        this.dataView.setUint8(this.position + 1, b1);
+        this.dataView.setUint8(this.position + 2, b0);
 
-    this.position = end;
-};
+        this.position = end;
+    }
 
-/**
- *
- * @param {number} value
- */
-BinaryBuffer.prototype.writeUint24LE = function (value) {
-    const end = this.position + 3;
+    /**
+     *
+     * @param {number} value
+     */
+    writeUint24LE(value) {
+        const end = this.position + 3;
 
-    this.ensureCapacity(end);
+        this.ensureCapacity(end);
 
-    const b0 = value & 0xFF;
-    const b1 = (value >> 8) & 0xFF;
-    const b2 = (value >> 16) & 0xFF;
+        const b0 = value & 0xFF;
+        const b1 = (value >> 8) & 0xFF;
+        const b2 = (value >> 16) & 0xFF;
 
-    this.dataView.setUint8(this.position, b0);
-    this.dataView.setUint8(this.position + 1, b1);
-    this.dataView.setUint8(this.position + 2, b2);
+        this.dataView.setUint8(this.position, b0);
+        this.dataView.setUint8(this.position + 1, b1);
+        this.dataView.setUint8(this.position + 2, b2);
 
-    this.position = end;
-};
+        this.position = end;
+    }
 
-/**
- * 2^31-1, values above this will be cropped incorrectly when bit-shifting
- * @type {number}
- */
-const MAX_SAFE_UINT_VAR = 2147483647;
+    /**
+     * Write Uint of variable length
+     * NOTE: uses 7-bit encoding with 1 bit used for carry-over flag
+     * @param {number} value
+     */
+    writeUintVar(value) {
+        assert.isNonNegativeInteger(value, 'value');
+        assert.ok(value <= MAX_SAFE_UINT_VAR, `value=[${value}] exceeds maximum safe limit[=${MAX_SAFE_UINT_VAR}]`);
 
-/**
- * Write Uint of variable length
- * NOTE: uses 7-bit encoding with 1 bit used for carry-over flag
- * @param {number} value
- */
-BinaryBuffer.prototype.writeUintVar = function (value) {
-    assert.isNonNegativeInteger(value, 'value');
-    assert.ok(value <= MAX_SAFE_UINT_VAR, `value=[${value}] exceeds maximum safe limit[=${MAX_SAFE_UINT_VAR}]`);
+        let first = true;
 
-    let first = true;
+        while (first || value !== 0) {
+            first = false;
 
-    while (first || value !== 0) {
-        first = false;
+            let lower7bits = (value & 0x7f);
 
-        let lower7bits = (value & 0x7f);
+            value >>= 7;
 
-        value >>= 7;
+            if (value > 0) {
+                //write carry-over flag
+                lower7bits |= 128;
+            }
 
-        if (value > 0) {
-            //write carry-over flag
-            lower7bits |= 128;
+            this.writeUint8(lower7bits);
         }
-
-        this.writeUint8(lower7bits);
     }
-};
 
-/**
- * Read Uint of variable length, a compliment to {@link #writeUintVar}
- * @returns {number}
- */
-BinaryBuffer.prototype.readUintVar = function () {
-    let more = true;
-    let value = 0;
-    let shift = 0;
+    /**
+     * Read Uint of variable length, a compliment to {@link #writeUintVar}
+     * @returns {number}
+     */
+    readUintVar() {
+        let more = true;
+        let value = 0;
+        let shift = 0;
 
-    while (more) {
-        let lower7bits = this.readUint8();
+        while (more) {
+            let lower7bits = this.readUint8();
 
-        //read carry-over flag
-        more = (lower7bits & 128) !== 0;
+            //read carry-over flag
+            more = (lower7bits & 128) !== 0;
 
-        //read value part of the byte
-        value |= (lower7bits & 0x7f) << shift;
+            //read value part of the byte
+            value |= (lower7bits & 0x7f) << shift;
 
-        //increment shift
-        shift += 7;
-    }
+            //increment shift
+            shift += 7;
+        }
 
-    return value;
-};
+        return value;
+    }
 
+    /**
+     *
+     * @param {number} value
+     */
+    writeUint32(value) {
+        const end = this.position + 4;
+        this.ensureCapacity(end);
 
-/**
- *
- * @param {number} value
- */
-BinaryBuffer.prototype.writeUint32 = function (value) {
-    const end = this.position + 4;
-    this.ensureCapacity(end);
+        this.dataView.setUint32(this.position, value, this.endianness);
 
-    this.dataView.setUint32(this.position, value, this.endianness);
+        this.position = end;
+    }
 
-    this.position = end;
-};
+    /**
+     *
+     * @param {number} value
+     */
+    writeUint32BE(value) {
+        const end = this.position + 4;
+        this.ensureCapacity(end);
 
-/**
- *
- * @param {number} value
- */
-BinaryBuffer.prototype.writeUint32BE = function (value) {
-    const end = this.position + 4;
-    this.ensureCapacity(end);
+        this.dataView.setUint32(this.position, value, EndianType.BigEndian);
 
-    this.dataView.setUint32(this.position, value, EndianType.BigEndian);
+        this.position = end;
+    }
 
-    this.position = end;
-};
+    /**
+     *
+     * @param {number} value
+     */
+    writeUint32LE(value) {
+        const end = this.position + 4;
+        this.ensureCapacity(end);
 
-/**
- *
- * @param {number} value
- */
-BinaryBuffer.prototype.writeUint32LE = function (value) {
-    const end = this.position + 4;
-    this.ensureCapacity(end);
+        this.dataView.setUint32(this.position, value, EndianType.LittleEndian);
 
-    this.dataView.setUint32(this.position, value, EndianType.LittleEndian);
+        this.position = end;
+    }
 
-    this.position = end;
-};
+    /**
+     *
+     * @param {Uint8Array|Uint8ClampedArray} array
+     * @param {number} source_offset
+     * @param {number} length
+     */
+    writeBytes(array, source_offset, length) {
+        const source_end = source_offset + length;
+        assert.greaterThanOrEqual(array.length, source_end, 'source array underflow');
 
-/**
- *
- * @param {Uint8Array|Uint8ClampedArray} array
- * @param {number} source_offset
- * @param {number} length
- */
-BinaryBuffer.prototype.writeBytes = function (array, source_offset, length) {
-    const source_end = source_offset + length;
-    assert.greaterThanOrEqual(array.length, source_end, 'source array underflow');
+        const targetAddress = this.position;
 
-    const targetAddress = this.position;
+        const end = targetAddress + length;
 
-    const end = targetAddress + length;
+        this.ensureCapacity(end);
 
-    this.ensureCapacity(end);
+        if (source_offset === 0 && array.length === length) {
+            // copying entire source array
 
-    if (source_offset === 0 && array.length === length) {
-        // copying entire source array
+            this.__data_uint8.set(array, targetAddress);
 
-        this.__data_uint8.set(array, targetAddress);
+        } else if (typeof array.subarray === "function") {
+            // typed array, use "subarray" method
 
-    } else if (typeof array.subarray === "function") {
-        // typed array, use "subarray" method
+            this.__data_uint8.set(array.subarray(source_offset, source_end), targetAddress);
 
-        this.__data_uint8.set(array.subarray(source_offset, source_end), targetAddress);
+        } else {
+            // not a typed array, copy byte by byte manually
 
-    } else {
-        // not a typed array, copy byte by byte manually
+            for (let i = 0; i < length; i++) {
+                this.__data_uint8[targetAddress + i] = array[source_offset + i];
+            }
 
-        for (let i = 0; i < length; i++) {
-            this.__data_uint8[targetAddress + i] = array[source_offset + i];
         }
 
+        this.position = end;
     }
 
-    this.position = end;
-};
+    /**
+     *
+     * @param {Uint8Array} destination
+     * @param {number} destination_offset
+     * @param {number} length
+     */
+    readBytes(destination, destination_offset, length) {
+        const source_position = this.position;
 
-/**
- *
- * @param {Uint8Array} destination
- * @param {number} destination_offset
- * @param {number} length
- */
-BinaryBuffer.prototype.readBytes = function (destination, destination_offset, length) {
-    const source_position = this.position;
+        const end = source_position + length;
 
-    const end = source_position + length;
+        const uint8 = this.__data_uint8;
 
-    const uint8 = this.__data_uint8;
+        if (length < 128) {
+            // small copy
+            array_copy(uint8, source_position, destination, destination_offset, length);
+        } else {
+            destination.set(uint8.subarray(source_position, end), destination_offset);
+        }
 
-    if (length < 128) {
-        // small copy
-        array_copy(uint8, source_position, destination, destination_offset, length);
-    } else {
-        destination.set(uint8.subarray(source_position, end), destination_offset);
+        this.position = end;
     }
 
-    this.position = end;
-};
-
-
-/**
- * Adapted from https://github.com/samthor/fast-text-encoding/blob/master/text.js
- * @licence Original license is Apache 2.0
- * @param {String} string
- */
-BinaryBuffer.prototype.writeUTF8String = function (string) {
-    if (string === null) {
-        //mark NULL
-        this.writeUint32(4294967295);
-        //bail, no string data to write
-        return;
-    } else if (string === undefined) {
-        //mark undefined
-        this.writeUint32(4294967294);
-
-        return;
-    }
+    /**
+     * Adapted from https://github.com/samthor/fast-text-encoding/blob/master/text.js
+     * @licence Original license is Apache 2.0
+     * @param {String} string
+     */
+    writeUTF8String(string) {
+        if (string === null) {
+            //mark NULL
+            this.writeUint32(4294967295);
+            //bail, no string data to write
+            return;
+        } else if (string === undefined) {
+            //mark undefined
+            this.writeUint32(4294967294);
+
+            return;
+        }
 
 
-    let pos = 0;
-    const len = string.length;
+        let pos = 0;
+        const len = string.length;
 
-    if (len >= 4294967294) {
-        throw new Error('String is too long');
-    }
+        if (len >= 4294967294) {
+            throw new Error('String is too long');
+        }
 
-    //mark non-NULL
-    this.writeUint32(len);
+        //mark non-NULL
+        this.writeUint32(len);
 
-    const startPosition = this.position;
+        const startPosition = this.position;
 
-    let at = startPosition;  // output position
+        let at = startPosition;  // output position
 
-    let tlen = Math.max(32, len + (len >> 1) + 7);  // 1.5x size
+        let tlen = Math.max(32, len + (len >> 1) + 7);  // 1.5x size
 
-    this.ensureCapacity(tlen + at);
+        this.ensureCapacity(tlen + at);
 
-    let target = this.__data_uint8;  // ... but at 8 byte offset
+        let target = this.__data_uint8;  // ... but at 8 byte offset
 
 
-    while (pos < len) {
-        let value = string.charCodeAt(pos++);
-        if (value >= 0xd800 && value <= 0xdbff) {
-            // high surrogate
-            if (pos < len) {
-                const extra = string.charCodeAt(pos);
-                if ((extra & 0xfc00) === 0xdc00) {
-                    ++pos;
-                    value = ((value & 0x3ff) << 10) + (extra & 0x3ff) + 0x10000;
-                }
-            }
+        while (pos < len) {
+            let value = string.charCodeAt(pos++);
             if (value >= 0xd800 && value <= 0xdbff) {
-                continue;  // drop lone surrogate
+                // high surrogate
+                if (pos < len) {
+                    const extra = string.charCodeAt(pos);
+                    if ((extra & 0xfc00) === 0xdc00) {
+                        ++pos;
+                        value = ((value & 0x3ff) << 10) + (extra & 0x3ff) + 0x10000;
+                    }
+                }
+                if (value >= 0xd800 && value <= 0xdbff) {
+                    continue;  // drop lone surrogate
+                }
             }
-        }
 
-        // expand the buffer if we couldn't write 4 bytes
-        if (at + 4 > this.capacity) {
-            tlen += 8;  // minimum extra
-            tlen *= (1.0 + (pos / len) * 2);  // take 2x the remaining
-            tlen = (tlen >> 3) << 3;  // 8 byte offset
+            // expand the buffer if we couldn't write 4 bytes
+            if (at + 4 > this.capacity) {
+                tlen += 8;  // minimum extra
+                tlen *= (1.0 + (pos / len) * 2);  // take 2x the remaining
+                tlen = (tlen >> 3) << 3;  // 8 byte offset
 
-            this.ensureCapacity(tlen + startPosition);
+                this.ensureCapacity(tlen + startPosition);
 
-            target = this.__data_uint8;
-        }
+                target = this.__data_uint8;
+            }
 
-        if ((value & 0xffffff80) === 0) {  // 1-byte
-            target[at++] = value;  // ASCII
-            continue;
-        } else if ((value & 0xfffff800) === 0) {  // 2-byte
-            target[at++] = ((value >> 6) & 0x1f) | 0xc0;
-        } else if ((value & 0xffff0000) === 0) {  // 3-byte
-            target[at++] = ((value >> 12) & 0x0f) | 0xe0;
-            target[at++] = ((value >> 6) & 0x3f) | 0x80;
-        } else if ((value & 0xffe00000) === 0) {  // 4-byte
-            target[at++] = ((value >> 18) & 0x07) | 0xf0;
-            target[at++] = ((value >> 12) & 0x3f) | 0x80;
-            target[at++] = ((value >> 6) & 0x3f) | 0x80;
-        } else {
-            // FIXME: do we care
-            continue;
+            if ((value & 0xffffff80) === 0) {  // 1-byte
+                target[at++] = value;  // ASCII
+                continue;
+            } else if ((value & 0xfffff800) === 0) {  // 2-byte
+                target[at++] = ((value >> 6) & 0x1f) | 0xc0;
+            } else if ((value & 0xffff0000) === 0) {  // 3-byte
+                target[at++] = ((value >> 12) & 0x0f) | 0xe0;
+                target[at++] = ((value >> 6) & 0x3f) | 0x80;
+            } else if ((value & 0xffe00000) === 0) {  // 4-byte
+                target[at++] = ((value >> 18) & 0x07) | 0xf0;
+                target[at++] = ((value >> 12) & 0x3f) | 0x80;
+                target[at++] = ((value >> 6) & 0x3f) | 0x80;
+            } else {
+                // FIXME: do we care
+                continue;
+            }
+
+            target[at++] = (value & 0x3f) | 0x80;
         }
 
-        target[at++] = (value & 0x3f) | 0x80;
+        this.position = at;
     }
 
-    this.position = at;
-};
-
-/**
- * Adapted from https://github.com/samthor/fast-text-encoding/blob/master/text.js
- * @licence Original license is Apache 2.0
- * @returns {String}
- */
-BinaryBuffer.prototype.readUTF8String = function () {
-    //check for null
-    const stringLength = this.readUint32();
-
-    if (stringLength === 4294967295) {
-        //null string
-        return null;
-    } else if (stringLength === 4294967294) {
-        //undefined string
-        return undefined;
-    }
+    /**
+     * Adapted from https://github.com/samthor/fast-text-encoding/blob/master/text.js
+     * @licence Original license is Apache 2.0
+     * @returns {String}
+     */
+    readUTF8String() {
+        //check for null
+        const stringLength = this.readUint32();
+
+        if (stringLength === 4294967295) {
+            //null string
+            return null;
+        } else if (stringLength === 4294967294) {
+            //undefined string
+            return undefined;
+        }
 
-    const bytes = this.__data_uint8;
+        const bytes = this.__data_uint8;
 
 
-    let result = "";
+        let result = "";
 
-    let i = this.position;
+        let i = this.position;
 
-    let charCount = 0;
+        let charCount = 0;
 
-    while (i < this.capacity && charCount < stringLength) {
-        const byte1 = bytes[i++];
-        let codePoint;
+        while (i < this.capacity && charCount < stringLength) {
+            const byte1 = bytes[i++];
+            let codePoint;
 
-        if (byte1 === 0) {
-            break;  // NULL
-        }
+            if (byte1 === 0) {
+                break;  // NULL
+            }
 
-        if ((byte1 & 0x80) === 0) {  // 1-byte
-            codePoint = byte1;
-        } else if ((byte1 & 0xe0) === 0xc0) {  // 2-byte
-            const byte2 = bytes[i++] & 0x3f;
-            codePoint = (((byte1 & 0x1f) << 6) | byte2);
-        } else if ((byte1 & 0xf0) === 0xe0) {
-            const byte2 = bytes[i++] & 0x3f;
-            const byte3 = bytes[i++] & 0x3f;
-            codePoint = (((byte1 & 0x1f) << 12) | (byte2 << 6) | byte3);
-        } else if ((byte1 & 0xf8) === 0xf0) {
-            const byte2 = bytes[i++] & 0x3f;
-            const byte3 = bytes[i++] & 0x3f;
-            const byte4 = bytes[i++] & 0x3f;
-
-            // this can be > 0xffff, so possibly generate surrogates
-            codePoint = ((byte1 & 0x07) << 0x12) | (byte2 << 0x0c) | (byte3 << 0x06) | byte4;
-            if (codePoint > 0xffff) {
-                // codepoint &= ~0x10000;
-                codePoint -= 0x10000;
-
-                result += String.fromCharCode((codePoint >>> 10) & 0x3ff | 0xd800);
-                charCount++;
-
-                codePoint = 0xdc00 | codePoint & 0x3ff;
+            if ((byte1 & 0x80) === 0) {  // 1-byte
+                codePoint = byte1;
+            } else if ((byte1 & 0xe0) === 0xc0) {  // 2-byte
+                const byte2 = bytes[i++] & 0x3f;
+                codePoint = (((byte1 & 0x1f) << 6) | byte2);
+            } else if ((byte1 & 0xf0) === 0xe0) {
+                const byte2 = bytes[i++] & 0x3f;
+                const byte3 = bytes[i++] & 0x3f;
+                codePoint = (((byte1 & 0x1f) << 12) | (byte2 << 6) | byte3);
+            } else if ((byte1 & 0xf8) === 0xf0) {
+                const byte2 = bytes[i++] & 0x3f;
+                const byte3 = bytes[i++] & 0x3f;
+                const byte4 = bytes[i++] & 0x3f;
+
+                // this can be > 0xffff, so possibly generate surrogates
+                codePoint = ((byte1 & 0x07) << 0x12) | (byte2 << 0x0c) | (byte3 << 0x06) | byte4;
+                if (codePoint > 0xffff) {
+                    // codepoint &= ~0x10000;
+                    codePoint -= 0x10000;
+
+                    result += String.fromCharCode((codePoint >>> 10) & 0x3ff | 0xd800);
+                    charCount++;
+
+                    codePoint = 0xdc00 | codePoint & 0x3ff;
+                }
+            } else {
+                // FIXME: we're ignoring this
             }
-        } else {
-            // FIXME: we're ignoring this
+
+            charCount++;
+            result += String.fromCharCode(codePoint);
+
         }
 
-        charCount++;
-        result += String.fromCharCode(codePoint);
+        this.position = i;
 
+        return result;
     }
 
-    this.position = i;
-
-    return result;
-};
+    /**
+     *
+     * @param {string} string
+     */
+    writeASCIIString(string) {
+        const char_count = string.length;
 
-/**
- *
- * @param {string} string
- */
-BinaryBuffer.prototype.writeASCIIString = function (string) {
-    const char_count = string.length;
+        const start = this.position;
+        const end = start + char_count;
 
-    const start = this.position;
-    const end = start + char_count;
+        this.ensureCapacity(end);
 
-    this.ensureCapacity(end);
+        for (let i = 0; i < char_count; i++) {
+            const char_code = string.charCodeAt(i);
 
-    for (let i = 0; i < char_count; i++) {
-        const char_code = string.charCodeAt(i);
+            if (char_code > 0xFF) {
+                throw new Error(`Character ${String.fromCharCode(char_code)} can\'t be represented by a US-ASCII byte.`);
+            }
 
-        if (char_code > 0xFF) {
-            throw new Error(`Character ${String.fromCharCode(char_code)} can\'t be represented by a US-ASCII byte.`);
+            this.__data_uint8[start + i] = char_code;
         }
 
-        this.__data_uint8[start + i] = char_code;
+        this.position = end;
     }
 
-    this.position = end;
-};
+    /**
+     *
+     * @param {number} length
+     * @returns {string}
+     */
+    readASCIICharacters(length) {
+        let result = "";
 
-/**
- *
- * @param {number} length
- * @returns {string}
- */
-BinaryBuffer.prototype.readASCIICharacters = function (length) {
-    let result = "";
+        for (let i = 0; i < length; i++) {
+            const code = this.readUint8();
 
-    for (let i = 0; i < length; i++) {
-        const code = this.readUint8();
+            result += String.fromCharCode(code);
+        }
 
-        result += String.fromCharCode(code);
+        return result;
     }
 
-    return result;
-};
+    /**
+     *
+     * @param {ArrayBuffer} v
+     * @return {BinaryBuffer}
+     */
+    static fromArrayBuffer(v) {
+        const r = new BinaryBuffer();
 
-/**
- *
- * @param {BinaryBuffer} source
- * @param {BinaryBuffer} target
- * @returns {string} Copied value
- */
-BinaryBuffer.copyUTF8String = function (source, target) {
-    const v = source.readUTF8String();
+        r.fromArrayBuffer(v);
+
+        return r;
+    }
 
-    target.writeUTF8String(v);
+    /**
+     *
+     * @param {BinaryBuffer} source
+     * @param {BinaryBuffer} target
+     * @returns {string} Copied value
+     */
+    static copyUTF8String(source, target) {
+        const v = source.readUTF8String();
 
-    return v;
-};
-/**
- *
- * @param {BinaryBuffer} source
- * @param {BinaryBuffer} target
- * @returns {number} Copied value
- */
-BinaryBuffer.copyUintVar = function (source, target) {
-    const v = source.readUintVar();
+        target.writeUTF8String(v);
 
-    target.writeUintVar(v);
+        return v;
+    }
 
-    return v;
-};
+    /**
+     *
+     * @param {BinaryBuffer} source
+     * @param {BinaryBuffer} target
+     * @returns {number} Copied value
+     */
+    static copyUintVar(source, target) {
+        const v = source.readUintVar();
 
-/**
- *
- * @param {BinaryBuffer} source
- * @param {BinaryBuffer} target
- * @returns {number} Copied value
- */
-BinaryBuffer.copyUint8 = function (source, target) {
-    const v = source.readUint8();
+        target.writeUintVar(v);
 
-    target.writeUint8(v);
+        return v;
+    }
 
-    return v;
-};
+    /**
+     *
+     * @param {BinaryBuffer} source
+     * @param {BinaryBuffer} target
+     * @returns {number} Copied value
+     */
+    static copyUint8(source, target) {
+        const v = source.readUint8();
 
-/**
- *
- * @param {BinaryBuffer} source
- * @param {BinaryBuffer} target
- * @returns {number} Copied value
- */
-BinaryBuffer.copyUint16 = function (source, target) {
-    const v = source.readUint16();
+        target.writeUint8(v);
 
-    target.writeUint16(v);
+        return v;
+    }
 
-    return v;
-};
-/**
- *
- * @param {BinaryBuffer} source
- * @param {BinaryBuffer} target
- * @returns {number} Copied value
- */
-BinaryBuffer.copyUint32 = function (source, target) {
-    const v = source.readUint32();
+    /**
+     *
+     * @param {BinaryBuffer} source
+     * @param {BinaryBuffer} target
+     * @returns {number} Copied value
+     */
+    static copyUint16(source, target) {
+        const v = source.readUint16();
 
-    target.writeUint32(v);
+        target.writeUint16(v);
 
-    return v;
-};
+        return v;
+    }
 
-/**
- *
- * @param {BinaryBuffer} source
- * @param {BinaryBuffer} target
- * @returns {number} Copied value
- */
-BinaryBuffer.copyFloat32 = function (source, target) {
-    const v = source.readFloat32();
+    /**
+     *
+     * @param {BinaryBuffer} source
+     * @param {BinaryBuffer} target
+     * @returns {number} Copied value
+     */
+    static copyUint32(source, target) {
+        const v = source.readUint32();
 
-    target.writeFloat32(v);
+        target.writeUint32(v);
 
-    return v;
-};
+        return v;
+    }
 
-/**
- *
- * @param {BinaryBuffer} source
- * @param {BinaryBuffer} target
- * @returns {number} Copied value
- */
-BinaryBuffer.copyFloat64 = function (source, target) {
-    const v = source.readFloat64();
+    /**
+     *
+     * @param {BinaryBuffer} source
+     * @param {BinaryBuffer} target
+     * @returns {number} Copied value
+     */
+    static copyFloat32(source, target) {
+        const v = source.readFloat32();
 
-    target.writeFloat64(v);
+        target.writeFloat32(v);
 
-    return v;
-};
+        return v;
+    }
 
-/**
- *
- * @param {BinaryBuffer} source
- * @param {BinaryBuffer} target
- * @param {number} length
- */
-BinaryBuffer.copyBytes = function (source, target, length) {
-    const temp = new Uint8Array(length);
+    /**
+     *
+     * @param {BinaryBuffer} source
+     * @param {BinaryBuffer} target
+     * @returns {number} Copied value
+     */
+    static copyFloat64(source, target) {
+        const v = source.readFloat64();
 
-    source.readBytes(temp, 0, length);
+        target.writeFloat64(v);
 
-    target.writeBytes(temp, 0, length);
+        return v;
+    }
 
-    return temp;
-};
+    /**
+     *
+     * @param {BinaryBuffer} source
+     * @param {BinaryBuffer} target
+     * @param {number} length
+     */
+    static copyBytes(source, target, length) {
+        const temp = new Uint8Array(length);
+
+        source.readBytes(temp, 0, length);
 
+        target.writeBytes(temp, 0, length);
 
-export { BinaryBuffer };
+        return temp;
+    }
+}