extended-buffer 6.1.0 → 7.0.1

package/dist/ExtendedBuffer.js

@@ -2,98 +2,116 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ExtendedBuffer = void 0;
 const buffer_1 = require("buffer");
+const utils = require("./utils");
+const errors_1 = require("./errors");
+const defaultCapacity = 512 * 1024;
+const defaultCapacityStep = defaultCapacity;
 class ExtendedBuffer {
     constructor(options) {
-        var _a;
-        this._maxBufferLength = (_a = options === null || options === void 0 ? void 0 : options.maxBufferLength) !== null && _a !== void 0 ? _a : (1024 * 1024);
-        this._initEmptyBuffer();
-    }
-    static get maxSize() {
-        return buffer_1.kMaxLength;
-    }
-    static concat(list, totalLength) {
-        let buffer = new this;
-        let listLength = list.length;
-        for (let i = 0; i < listLength; ++i) {
-            buffer.writeBuffer(list[i], false);
-            if (undefined !== totalLength && buffer.length >= totalLength) {
-                buffer._pointerEnd = buffer._pointerStart + totalLength;
-                break;
-            }
-        }
-        return buffer;
-    }
-    static zigZagEncode32(value) {
-        return (((value |= 0) << 1) ^ (value >> 31)) >>> 0;
-    }
-    static zigZagDecode32(value) {
-        return ((value >>> 1) ^ -(value & 1)) | 0;
+        var _a, _b;
+        this._capacity = (_a = options === null || options === void 0 ? void 0 : options.capacity) !== null && _a !== void 0 ? _a : defaultCapacity;
+        this._capacityStep = (_b = options === null || options === void 0 ? void 0 : options.capacityStep) !== null && _b !== void 0 ? _b : defaultCapacityStep;
+        utils.assertUnsignedInteger(this._capacity);
+        utils.assertUnsignedInteger(this._capacityStep);
+        this.initExtendedBuffer();
+    }
+    createInstance(options) {
+        const ThisClass = this.constructor;
+        return new ThisClass(options);
     }
     get length() {
         return this._pointerEnd - this._pointerStart;
     }
-    get nativeLength() {
+    get capacity() {
         return this._nativeBuffer.length;
     }
-    get buffer() {
-        return this._nativeBuffer.slice(this._pointerStart, this._pointerEnd);
+    get pointer() {
+        return this.getPointer();
     }
-    _initEmptyBuffer() {
-        if (this._maxBufferLength > buffer_1.kMaxLength) {
-            throw new RangeError(`"_maxBufferLength" cannot be more than ${buffer_1.kMaxLength} bytes`);
-        }
-        this._pointerStart = this._pointerEnd = Math.floor(this._maxBufferLength / 2);
-        this._nativeBuffer = buffer_1.Buffer.allocUnsafe ? buffer_1.Buffer.allocUnsafe(this._maxBufferLength) : new buffer_1.Buffer(this._maxBufferLength);
+    get nativeBufferView() {
+        return utils.nativeBufferSubarray(this._nativeBuffer, this._pointerStart, this._pointerEnd);
+    }
+    initExtendedBuffer() {
         this._pointer = 0;
+        this._nativeBuffer = utils.allocNativeBuffer(this._capacity);
+        this._pointerStart = this._pointerEnd = Math.floor(this._capacity / 2);
+        this.assertInstanceState();
+        return this;
+    }
+    assertInstanceState() {
+        if (!this._nativeBuffer ||
+            !Number.isSafeInteger(this._pointer) ||
+            !Number.isSafeInteger(this._pointerStart) ||
+            !Number.isSafeInteger(this._pointerEnd) ||
+            !Number.isSafeInteger(this._capacity) ||
+            !Number.isSafeInteger(this._capacityStep) ||
+            this._pointer < 0 ||
+            this._pointerStart < 0 ||
+            this._pointerEnd < 0 ||
+            this._capacity < 0 ||
+            this._capacityStep < 0 ||
+            this._pointerStart > this._pointerEnd ||
+            this._pointerEnd > this._nativeBuffer.length ||
+            this._pointer > (this._pointerEnd - this._pointerStart)) {
+            throw new errors_1.ExtendedBufferError('INVALID_INSTANCE_STATE');
+        }
         return this;
     }
     clean() {
-        return this._initEmptyBuffer();
+        return this.initExtendedBuffer();
     }
-    getFreeSpaceStart() {
+    nativePointer() {
+        return this._pointerStart + this._pointer;
+    }
+    getWritableSizeStart() {
         return this._pointerStart;
     }
-    getFreeSpaceEnd() {
+    getWritableSizeEnd() {
         return this._nativeBuffer.length - this._pointerEnd;
     }
-    getFreeSpace() {
-        return this.getFreeSpaceStart() + this.getFreeSpaceEnd();
+    getWritableSize() {
+        return this.getWritableSizeStart() + this.getWritableSizeEnd();
     }
-    allocStart(byteLength) {
-        if (byteLength > this.getFreeSpaceStart()) {
-            if (byteLength > this.getFreeSpace()) {
-                throw new RangeError('Not enough free space');
-            }
-            const offset = Math.floor((this.getFreeSpace() - byteLength) / 2) + byteLength - this._pointerStart;
-            this._nativeBuffer.copy(this._nativeBuffer, this._pointerStart + offset, this._pointerStart, this._pointerEnd);
-            this._pointerStart += offset;
-            this._pointerEnd += offset;
+    allocStart(size) {
+        utils.assertUnsignedInteger(size);
+        if (this.getWritableSizeStart() >= size) {
+            return this;
+        }
+        if (this.getWritableSize() < size) {
+            const newSize = this._nativeBuffer.length + (size - this.getWritableSize()) + this._capacityStep;
+            this._nativeBuffer = utils.reallocNativeBuffer(this._nativeBuffer, newSize);
         }
+        const offset = Math.floor((this.getWritableSize() - size) / 2) + size - this._pointerStart;
+        this._nativeBuffer.copy(this._nativeBuffer, this._pointerStart + offset, this._pointerStart, this._pointerEnd);
+        this._pointerStart += offset;
+        this._pointerEnd += offset;
+        this.assertInstanceState();
         return this;
     }
-    allocEnd(byteLength) {
-        if (byteLength > this.getFreeSpaceEnd()) {
-            if (byteLength > this.getFreeSpace()) {
-                throw new RangeError('Not enough free space');
-            }
-            let offset = this._nativeBuffer.length - Math.floor((this.getFreeSpace() - byteLength) / 2) - byteLength - this._pointerEnd;
-            this._nativeBuffer.copy(this._nativeBuffer, this._pointerStart + offset, this._pointerStart, this._pointerEnd);
-            this._pointerStart += offset;
-            this._pointerEnd += offset;
+    allocEnd(size) {
+        utils.assertUnsignedInteger(size);
+        if (this.getWritableSizeEnd() >= size) {
+            return this;
         }
+        if (this.getWritableSize() < size) {
+            const newSize = this._nativeBuffer.length + (size - this.getWritableSize()) + this._capacityStep;
+            this._nativeBuffer = utils.reallocNativeBuffer(this._nativeBuffer, newSize);
+        }
+        const offset = this._nativeBuffer.length - Math.floor((this.getWritableSize() - size) / 2) - size - this._pointerEnd;
+        this._nativeBuffer.copy(this._nativeBuffer, this._pointerStart + offset, this._pointerStart, this._pointerEnd);
+        this._pointerStart += offset;
+        this._pointerEnd += offset;
+        this.assertInstanceState();
         return this;
     }
     getReadableSize() {
         return this._pointerEnd - this._pointerStart - this._pointer;
     }
-    getWritableSize() {
-        return this.getFreeSpace();
-    }
-    _writeNativeBuffer(buffer, unshift) {
+    writeNativeBuffer(buffer, unshift) {
         if (unshift) {
             this.allocStart(buffer.length);
+            buffer.copy(this._nativeBuffer, this._pointerStart - buffer.length);
             this._pointerStart -= buffer.length;
-            buffer.copy(this._nativeBuffer, this._pointerStart);
         }
         else {
             this.allocEnd(buffer.length);
@@ -103,19 +121,33 @@ class ExtendedBuffer {
         return this;
     }
     gc() {
+        this.discardReadData();
+        const freeSize = this.getWritableSize();
+        if (freeSize > this._capacityStep) {
+            const reduceSize = freeSize - this._capacityStep;
+            const newNativeSize = this._nativeBuffer.length - reduceSize;
+            this.allocEnd(reduceSize);
+            this._nativeBuffer = utils.reallocNativeBuffer(this._nativeBuffer, newNativeSize);
+        }
+        return this;
+    }
+    discardReadData() {
         if (this._pointer > 0) {
-            let payload = this._nativeBuffer.slice(this._pointerStart + this._pointer, this._pointerEnd);
-            return this._initEmptyBuffer()._writeNativeBuffer(payload, false);
+            this._pointerStart += this._pointer;
+            this._pointer = 0;
         }
         return this;
     }
     nodeGc() {
-        global.gc && global.gc();
+        if (typeof global.gc === 'function') {
+            global.gc();
+        }
         return this;
     }
     setPointer(pointer) {
+        utils.assertInteger(pointer);
         if (pointer < 0 || pointer > this.length) {
-            throw new RangeError('Pointer out of range');
+            throw new errors_1.ExtendedBufferRangeError('POINTER_OUT_OF_RANGE');
         }
         this._pointer = pointer;
         return this;
@@ -124,304 +156,303 @@ class ExtendedBuffer {
         return this._pointer;
     }
     offset(offset) {
+        utils.assertInteger(offset);
         return this.setPointer(this._pointer + offset);
     }
-    isReadable(byteLength) {
-        byteLength = byteLength < 0 ? 0 : byteLength;
-        return this.getReadableSize() >= byteLength;
-    }
-    isWritable(byteLength = 1) {
-        byteLength = byteLength < 1 ? 1 : byteLength;
-        return this.getFreeSpace() >= byteLength;
-    }
-    toString(encoding, start, end) {
-        return this.buffer.toString(encoding, start, end);
+    isReadable(size) {
+        utils.assertUnsignedInteger(size);
+        return this.getReadableSize() >= size;
     }
     writeBuffer(value, unshift) {
         if (value instanceof buffer_1.Buffer) {
-            return this._writeNativeBuffer(value, unshift);
+            return this.writeNativeBuffer(value, unshift);
         }
-        if (value instanceof ExtendedBuffer) {
-            return this._writeNativeBuffer(value.buffer, unshift);
-        }
-        throw new TypeError('"value" is incorrect buffer');
+        return this.writeNativeBuffer(value.nativeBufferView, unshift);
     }
     writeString(string, encoding, unshift) {
-        let byteLength = buffer_1.Buffer.byteLength(string, encoding);
-        if (unshift) {
-            this.allocStart(byteLength);
-            this._pointerStart -= byteLength;
-            this._nativeBuffer.write(string, this._pointerStart, byteLength, encoding);
-        }
-        else {
-            this.allocEnd(byteLength);
-            this._nativeBuffer.write(string, this._pointerEnd, byteLength, encoding);
-            this._pointerEnd += byteLength;
-        }
-        return this;
+        const bytes = buffer_1.Buffer.from(string, encoding);
+        return this.writeNativeBuffer(bytes, unshift);
     }
-    writeIntBE(value, byteLength, unshift, noAssert) {
+    writeIntBE(value, size, unshift) {
+        utils.assertInteger(value);
+        utils.assertUnsignedInteger(size);
+        utils.assertIntegerSize(size);
         if (unshift) {
-            this.allocStart(byteLength);
-            this._pointerStart -= byteLength;
-            this._nativeBuffer.writeIntBE(value, this._pointerStart, byteLength, noAssert);
+            this.allocStart(size);
+            this._nativeBuffer.writeIntBE(value, this._pointerStart - size, size);
+            this._pointerStart -= size;
         }
         else {
-            this.allocEnd(byteLength);
-            this._nativeBuffer.writeIntBE(value, this._pointerEnd, byteLength, noAssert);
-            this._pointerEnd += byteLength;
+            this.allocEnd(size);
+            this._nativeBuffer.writeIntBE(value, this._pointerEnd, size);
+            this._pointerEnd += size;
         }
         return this;
     }
-    writeIntLE(value, byteLength, unshift, noAssert) {
+    writeIntLE(value, size, unshift) {
+        utils.assertInteger(value);
+        utils.assertUnsignedInteger(size);
+        utils.assertIntegerSize(size);
         if (unshift) {
-            this.allocStart(byteLength);
-            this._pointerStart -= byteLength;
-            this._nativeBuffer.writeIntLE(value, this._pointerStart, byteLength, noAssert);
+            this.allocStart(size);
+            this._nativeBuffer.writeIntLE(value, this._pointerStart - size, size);
+            this._pointerStart -= size;
         }
         else {
-            this.allocEnd(byteLength);
-            this._nativeBuffer.writeIntLE(value, this._pointerEnd, byteLength, noAssert);
-            this._pointerEnd += byteLength;
+            this.allocEnd(size);
+            this._nativeBuffer.writeIntLE(value, this._pointerEnd, size);
+            this._pointerEnd += size;
         }
         return this;
     }
-    writeUIntBE(value, byteLength, unshift, noAssert) {
+    writeUIntBE(value, size, unshift) {
+        utils.assertUnsignedInteger(value);
+        utils.assertUnsignedInteger(size);
+        utils.assertIntegerSize(size);
         if (unshift) {
-            this.allocStart(byteLength);
-            this._pointerStart -= byteLength;
-            this._nativeBuffer.writeUIntBE(value, this._pointerStart, byteLength, noAssert);
+            this.allocStart(size);
+            this._nativeBuffer.writeUIntBE(value, this._pointerStart - size, size);
+            this._pointerStart -= size;
         }
         else {
-            this.allocEnd(byteLength);
-            this._nativeBuffer.writeUIntBE(value, this._pointerEnd, byteLength, noAssert);
-            this._pointerEnd += byteLength;
+            this.allocEnd(size);
+            this._nativeBuffer.writeUIntBE(value, this._pointerEnd, size);
+            this._pointerEnd += size;
         }
         return this;
     }
-    writeUIntLE(value, byteLength, unshift, noAssert) {
+    writeUIntLE(value, size, unshift) {
+        utils.assertUnsignedInteger(value);
+        utils.assertUnsignedInteger(size);
+        utils.assertIntegerSize(size);
         if (unshift) {
-            this.allocStart(byteLength);
-            this._pointerStart -= byteLength;
-            this._nativeBuffer.writeUIntLE(value, this._pointerStart, byteLength, noAssert);
+            this.allocStart(size);
+            this._nativeBuffer.writeUIntLE(value, this._pointerStart - size, size);
+            this._pointerStart -= size;
         }
         else {
-            this.allocEnd(byteLength);
-            this._nativeBuffer.writeUIntLE(value, this._pointerEnd, byteLength, noAssert);
-            this._pointerEnd += byteLength;
+            this.allocEnd(size);
+            this._nativeBuffer.writeUIntLE(value, this._pointerEnd, size);
+            this._pointerEnd += size;
         }
         return this;
     }
-    writeInt8(value, unshift, noAssert) {
-        return this.writeIntBE(value, 1, unshift, noAssert);
+    writeInt8(value, unshift) {
+        return this.writeIntBE(value, 1, unshift);
     }
-    writeUInt8(value, unshift, noAssert) {
-        return this.writeUIntBE(value, 1, unshift, noAssert);
+    writeUInt8(value, unshift) {
+        return this.writeUIntLE(value, 1, unshift);
     }
-    writeInt16BE(value, unshift, noAssert) {
-        return this.writeIntBE(value, 2, unshift, noAssert);
+    writeInt16BE(value, unshift) {
+        return this.writeIntBE(value, 2, unshift);
     }
-    writeInt16LE(value, unshift, noAssert) {
-        return this.writeIntLE(value, 2, unshift, noAssert);
+    writeInt16LE(value, unshift) {
+        return this.writeIntLE(value, 2, unshift);
     }
-    writeUInt16BE(value, unshift, noAssert) {
-        return this.writeUIntBE(value, 2, unshift, noAssert);
+    writeUInt16BE(value, unshift) {
+        return this.writeUIntBE(value, 2, unshift);
     }
-    writeUInt16LE(value, unshift, noAssert) {
-        return this.writeUIntLE(value, 2, unshift, noAssert);
+    writeUInt16LE(value, unshift) {
+        return this.writeUIntLE(value, 2, unshift);
     }
-    writeInt32BE(value, unshift, noAssert) {
-        return this.writeIntBE(value, 4, unshift, noAssert);
+    writeInt32BE(value, unshift) {
+        return this.writeIntBE(value, 4, unshift);
     }
-    writeInt32LE(value, unshift, noAssert) {
-        return this.writeIntLE(value, 4, unshift, noAssert);
+    writeInt32LE(value, unshift) {
+        return this.writeIntLE(value, 4, unshift);
     }
-    writeUInt32BE(value, unshift, noAssert) {
-        return this.writeUIntBE(value, 4, unshift, noAssert);
+    writeUInt32BE(value, unshift) {
+        return this.writeUIntBE(value, 4, unshift);
     }
-    writeUInt32LE(value, unshift, noAssert) {
-        return this.writeUIntLE(value, 4, unshift, noAssert);
+    writeUInt32LE(value, unshift) {
+        return this.writeUIntLE(value, 4, unshift);
     }
-    writeFloatBE(value, unshift, noAssert) {
+    writeFloatBE(value, unshift) {
         if (unshift) {
             this.allocStart(4);
+            this._nativeBuffer.writeFloatBE(value, this._pointerStart - 4);
             this._pointerStart -= 4;
-            this._nativeBuffer.writeFloatBE(value, this._pointerStart, noAssert);
         }
         else {
             this.allocEnd(4);
-            this._nativeBuffer.writeFloatBE(value, this._pointerEnd, noAssert);
+            this._nativeBuffer.writeFloatBE(value, this._pointerEnd);
             this._pointerEnd += 4;
         }
         return this;
     }
-    writeFloatLE(value, unshift, noAssert) {
+    writeFloatLE(value, unshift) {
         if (unshift) {
             this.allocStart(4);
+            this._nativeBuffer.writeFloatLE(value, this._pointerStart - 4);
             this._pointerStart -= 4;
-            this._nativeBuffer.writeFloatLE(value, this._pointerStart, noAssert);
         }
         else {
             this.allocEnd(4);
-            this._nativeBuffer.writeFloatLE(value, this._pointerEnd, noAssert);
+            this._nativeBuffer.writeFloatLE(value, this._pointerEnd);
             this._pointerEnd += 4;
         }
         return this;
     }
-    writeDoubleBE(value, unshift, noAssert) {
+    writeDoubleBE(value, unshift) {
         if (unshift) {
             this.allocStart(8);
+            this._nativeBuffer.writeDoubleBE(value, this._pointerStart - 8);
             this._pointerStart -= 8;
-            this._nativeBuffer.writeDoubleBE(value, this._pointerStart, noAssert);
         }
         else {
             this.allocEnd(8);
-            this._nativeBuffer.writeDoubleBE(value, this._pointerEnd, noAssert);
+            this._nativeBuffer.writeDoubleBE(value, this._pointerEnd);
             this._pointerEnd += 8;
         }
         return this;
     }
-    writeDoubleLE(value, unshift, noAssert) {
+    writeDoubleLE(value, unshift) {
         if (unshift) {
             this.allocStart(8);
+            this._nativeBuffer.writeDoubleLE(value, this._pointerStart - 8);
             this._pointerStart -= 8;
-            this._nativeBuffer.writeDoubleLE(value, this._pointerStart, noAssert);
         }
         else {
             this.allocEnd(8);
-            this._nativeBuffer.writeDoubleLE(value, this._pointerEnd, noAssert);
+            this._nativeBuffer.writeDoubleLE(value, this._pointerEnd);
             this._pointerEnd += 8;
         }
         return this;
     }
-    writeVarInt32(value, unshift) {
-        value >>>= 0;
-        let b;
-        if (unshift) {
-            let buffer = new ExtendedBuffer({
-                maxBufferLength: 10
-            });
-            while (value >= 0x80) {
-                b = (value & 0x7f) | 0x80;
-                buffer.writeUIntBE(b, 1);
-                value >>>= 7;
-            }
-            buffer.writeUIntBE(value, 1);
-            return this._writeNativeBuffer(buffer.buffer, true);
-        }
-        while (value >= 0x80) {
-            b = (value & 0x7f) | 0x80;
-            this.writeUIntBE(b, 1);
-            value >>>= 7;
-        }
-        return this.writeUIntBE(value, 1);
-    }
     readBuffer(size, asNative, bufferOptions) {
-        let buffer = this._nativeBuffer.slice(this._pointerStart + this._pointer, this._pointerStart + this._pointer + size);
-        this._pointer += size;
-        const ThisClass = this.constructor;
+        utils.assertUnsignedInteger(size);
+        if (!this.isReadable(size)) {
+            throw new errors_1.ExtendedBufferRangeError('SIZE_OUT_OF_RANGE');
+        }
+        let result;
+        const buffer = utils.nativeBufferSubarray(this._nativeBuffer, this.nativePointer(), this.nativePointer() + size);
         if (asNative) {
-            return buffer_1.Buffer.from ? buffer_1.Buffer.from(buffer) : new buffer_1.Buffer(buffer);
+            result = buffer_1.Buffer.from(buffer);
+        }
+        else {
+            bufferOptions = Object.assign({
+                capacity: this._capacity,
+                capacityStep: this._capacityStep
+            }, bufferOptions !== null && bufferOptions !== void 0 ? bufferOptions : {});
+            result = this.createInstance(bufferOptions).writeNativeBuffer(buffer);
         }
-        return (new ThisClass(bufferOptions))._writeNativeBuffer(buffer, false);
+        this.offset(size);
+        return result;
     }
     readString(size, encoding) {
-        this._pointer += size;
-        return this._nativeBuffer.toString(encoding, this._pointerStart + this._pointer - size, this._pointerStart + this._pointer);
-    }
-    readIntBE(byteLength, noAssert) {
-        this._pointer += byteLength;
-        return this._nativeBuffer.readIntBE(this._pointerStart + this._pointer - byteLength, byteLength, noAssert);
-    }
-    readIntLE(byteLength, noAssert) {
-        this._pointer += byteLength;
-        return this._nativeBuffer.readIntLE(this._pointerStart + this._pointer - byteLength, byteLength, noAssert);
-    }
-    readUIntBE(byteLength, noAssert) {
-        this._pointer += byteLength;
-        return this._nativeBuffer.readUIntBE(this._pointerStart + this._pointer - byteLength, byteLength, noAssert);
-    }
-    readUIntLE(byteLength, noAssert) {
-        this._pointer += byteLength;
-        return this._nativeBuffer.readUIntLE(this._pointerStart + this._pointer - byteLength, byteLength, noAssert);
-    }
-    readInt8(noAssert) {
-        return this.readIntBE(1, noAssert);
-    }
-    readUInt8(noAssert) {
-        return this.readUIntBE(1, noAssert);
-    }
-    readInt16BE(noAssert) {
-        return this.readIntBE(2, noAssert);
-    }
-    readInt16LE(noAssert) {
-        return this.readIntLE(2, noAssert);
-    }
-    readUInt16BE(noAssert) {
-        return this.readUIntBE(2, noAssert);
-    }
-    readUInt16LE(noAssert) {
-        return this.readUIntLE(2, noAssert);
-    }
-    readInt32BE(noAssert) {
-        return this.readIntBE(4, noAssert);
-    }
-    readInt32LE(noAssert) {
-        return this.readIntLE(4, noAssert);
-    }
-    readUInt32BE(noAssert) {
-        return this.readUIntBE(4, noAssert);
-    }
-    readUInt32LE(noAssert) {
-        return this.readUIntLE(4, noAssert);
-    }
-    readFloatBE(noAssert) {
-        this._pointer += 4;
-        return this._nativeBuffer.readFloatBE(this._pointerStart + this._pointer - 4, noAssert);
-    }
-    readFloatLE(noAssert) {
-        this._pointer += 4;
-        return this._nativeBuffer.readFloatLE(this._pointerStart + this._pointer - 4, noAssert);
-    }
-    readDoubleBE(noAssert) {
-        this._pointer += 8;
-        return this._nativeBuffer.readDoubleBE(this._pointerStart + this._pointer - 8, noAssert);
-    }
-    readDoubleLE(noAssert) {
-        this._pointer += 8;
-        return this._nativeBuffer.readDoubleLE(this._pointerStart + this._pointer - 8, noAssert);
-    }
-    readVarInt32() {
-        let c = 0;
-        let value = 0 >>> 0;
-        let b;
-        do {
-            b = this.readUIntBE(1);
-            if (c < 5) {
-                value |= (b & 0x7f) << (7 * c);
-            }
-            ++c;
-        } while ((b & 0x80) !== 0);
-        return value | 0;
-    }
-    isReadableVarInt32() {
-        let c = 0;
-        let value = 0 >>> 0;
-        let b;
-        let oldPointer = this._pointer;
-        do {
-            if (!this.isReadable(1)) {
-                this._pointer = oldPointer;
-                return false;
-            }
-            b = this.readUIntBE(1);
-            if (c < 5) {
-                value |= (b & 0x7f) << (7 * c);
-            }
-            ++c;
-        } while ((b & 0x80) !== 0);
-        this._pointer = oldPointer;
-        return true;
+        utils.assertUnsignedInteger(size);
+        if (!this.isReadable(size)) {
+            throw new errors_1.ExtendedBufferRangeError('SIZE_OUT_OF_RANGE');
+        }
+        const result = this._nativeBuffer.toString(encoding, this.nativePointer(), this.nativePointer() + size);
+        this.offset(size);
+        return result;
+    }
+    readIntBE(size) {
+        utils.assertUnsignedInteger(size);
+        utils.assertIntegerSize(size);
+        if (!this.isReadable(size)) {
+            throw new errors_1.ExtendedBufferRangeError('SIZE_OUT_OF_RANGE');
+        }
+        const result = this._nativeBuffer.readIntBE(this.nativePointer(), size);
+        this.offset(size);
+        return result;
+    }
+    readIntLE(size) {
+        utils.assertUnsignedInteger(size);
+        utils.assertIntegerSize(size);
+        if (!this.isReadable(size)) {
+            throw new errors_1.ExtendedBufferRangeError('SIZE_OUT_OF_RANGE');
+        }
+        const result = this._nativeBuffer.readIntLE(this.nativePointer(), size);
+        this.offset(size);
+        return result;
+    }
+    readUIntBE(size) {
+        utils.assertUnsignedInteger(size);
+        utils.assertIntegerSize(size);
+        if (!this.isReadable(size)) {
+            throw new errors_1.ExtendedBufferRangeError('SIZE_OUT_OF_RANGE');
+        }
+        const result = this._nativeBuffer.readUIntBE(this.nativePointer(), size);
+        this.offset(size);
+        return result;
+    }
+    readUIntLE(size) {
+        utils.assertUnsignedInteger(size);
+        utils.assertIntegerSize(size);
+        if (!this.isReadable(size)) {
+            throw new errors_1.ExtendedBufferRangeError('SIZE_OUT_OF_RANGE');
+        }
+        const result = this._nativeBuffer.readUIntLE(this.nativePointer(), size);
+        this.offset(size);
+        return result;
+    }
+    readInt8() {
+        return this.readIntBE(1);
+    }
+    readUInt8() {
+        return this.readUIntLE(1);
+    }
+    readInt16BE() {
+        return this.readIntBE(2);
+    }
+    readInt16LE() {
+        return this.readIntLE(2);
+    }
+    readUInt16BE() {
+        return this.readUIntBE(2);
+    }
+    readUInt16LE() {
+        return this.readUIntLE(2);
+    }
+    readInt32BE() {
+        return this.readIntBE(4);
+    }
+    readInt32LE() {
+        return this.readIntLE(4);
+    }
+    readUInt32BE() {
+        return this.readUIntBE(4);
+    }
+    readUInt32LE() {
+        return this.readUIntLE(4);
+    }
+    readFloatBE() {
+        const size = 4;
+        if (!this.isReadable(size)) {
+            throw new errors_1.ExtendedBufferRangeError('SIZE_OUT_OF_RANGE');
+        }
+        const result = this._nativeBuffer.readFloatBE(this.nativePointer());
+        this.offset(size);
+        return result;
+    }
+    readFloatLE() {
+        const size = 4;
+        if (!this.isReadable(size)) {
+            throw new errors_1.ExtendedBufferRangeError('SIZE_OUT_OF_RANGE');
+        }
+        const result = this._nativeBuffer.readFloatLE(this.nativePointer());
+        this.offset(size);
+        return result;
+    }
+    readDoubleBE() {
+        const size = 8;
+        if (!this.isReadable(size)) {
+            throw new errors_1.ExtendedBufferRangeError('SIZE_OUT_OF_RANGE');
+        }
+        const result = this._nativeBuffer.readDoubleBE(this.nativePointer());
+        this.offset(size);
+        return result;
+    }
+    readDoubleLE() {
+        const size = 8;
+        if (!this.isReadable(size)) {
+            throw new errors_1.ExtendedBufferRangeError('SIZE_OUT_OF_RANGE');
+        }
+        const result = this._nativeBuffer.readDoubleLE(this.nativePointer());
+        this.offset(size);
+        return result;
     }
 }
 exports.ExtendedBuffer = ExtendedBuffer;