extended-buffer 7.2.1 → 7.3.1

package/README.md

@@ -120,6 +120,28 @@ Fixed-width helpers:
 - `writeInt16BE`, `writeInt16LE`, `writeUInt16BE`, `writeUInt16LE`
 - `writeInt32BE`, `writeInt32LE`, `writeUInt32BE`, `writeUInt32LE`
 
+### BigInt (64-bit integers)
+
+If your runtime supports `BigInt` and Node's `Buffer.readBig*` / `Buffer.writeBig*` APIs, you can read/write 64-bit integers as `bigint` values (always **8 bytes**):
+
+- `writeBigInt64BE`, `writeBigInt64LE` — signed 64-bit
+- `writeBigUInt64BE`, `writeBigUInt64LE` — unsigned 64-bit
+
+```ts
+import { ExtendedBuffer } from 'extended-buffer';
+
+const b = new ExtendedBuffer();
+
+b.writeBigUInt64BE(2n ** 63n); // 9223372036854775808n
+b.writeBigInt64LE(-42n);
+
+b.setPointer(0);
+console.log(b.readBigUInt64BE()); // 9223372036854775808n
+console.log(b.readBigInt64LE());  // -42n
+```
+
+If `BigInt` is not supported, these methods throw `ExtendedBufferUnsupportedError('EXECUTION_ENVIRONMENT_NOT_SUPPORT_BIG_INT')`.
+
 ### Floating point
 
 - `writeFloatBE`, `writeFloatLE` (4 bytes)
@@ -171,6 +193,24 @@ Fixed-width helpers:
 - `readInt16BE`, `readInt16LE`, `readUInt16BE`, `readUInt16LE`
 - `readInt32BE`, `readInt32LE`, `readUInt32BE`, `readUInt32LE`
 
+### BigInt (64-bit integers)
+
+- `readBigInt64BE`, `readBigInt64LE` — signed 64-bit
+- `readBigUInt64BE`, `readBigUInt64LE` — unsigned 64-bit
+
+```ts
+const b = new ExtendedBuffer();
+
+b.writeBigInt64BE(-1n);
+b.writeBigUInt64BE(18446744073709551615n); // 2^64 - 1
+
+b.setPointer(0);
+console.log(b.readBigInt64BE());  // -1n
+console.log(b.readBigUInt64BE()); // 18446744073709551615n
+```
+
+Note: Node's `Buffer` will throw a native `RangeError` if the value doesn't fit into signed/unsigned 64-bit range.
+
 ### Floating point
 
 - `readFloatBE`, `readFloatLE`
@@ -202,6 +242,85 @@ If you try to set the pointer outside `[0, length]`, it throws
 
 ---
 
+## Transactions (atomic changes)
+
+Sometimes you want to perform a **multi-step read/write** and either:
+
+- **commit** everything if it succeeds, or
+- **rollback** the buffer to the exact previous state if something fails.
+
+`ExtendedBuffer.transaction()` wraps your code in a transaction:
+
+```ts
+const result = b.transaction(() => {
+  // any reads/writes/offsets/etc.
+  return 123;
+});
+```
+
+Rules:
+
+- If the callback **returns normally**, changes are kept (committed).
+- If the callback **throws**, the buffer is restored (rolled back) and the error is re-thrown.
+- Transactions are **re-entrant**: nested `transaction()` calls do not create extra snapshots.
+
+What gets rolled back:
+
+- stored payload bytes
+- `pointer` (read pointer)
+- internal start/end offsets and the original native `Buffer` (even if the buffer was reallocated during the callback)
+
+### Example: "try parse" without consuming bytes
+
+This is useful for protocols where you might receive partial data and want to retry later.
+
+```ts
+import { ExtendedBuffer } from 'extended-buffer';
+
+function tryReadFrame(b: ExtendedBuffer): Buffer | null {
+  try {
+    return b.transaction(() => {
+      // (1) read header
+      const len = b.readUInt16BE();
+
+      // (2) not enough bytes yet -> rollback and let the caller wait for more data
+      if (!b.isReadable(len)) {
+        throw new Error('INCOMPLETE_FRAME');
+      }
+
+      // (3) success -> commit
+      return b.readBuffer(len, true);
+    });
+  } catch {
+    return null;
+  }
+}
+```
+
+### Example: rollback on validation error
+
+```ts
+b.transaction(() => {
+  const magic = b.readUInt32BE();
+  if (magic !== 0xdeadbeef) {
+    throw new Error('BAD_MAGIC');
+  }
+
+  const version = b.readUInt8();
+  if (version !== 1) {
+    throw new Error('UNSUPPORTED_VERSION');
+  }
+});
+```
+
+### Performance note
+
+`transaction()` snapshots the **current payload** (it copies the stored bytes) before running the callback.
+That makes rollbacks safe, but can be expensive for very large buffers. Use it for small/medium payloads,
+or when the safety/ergonomics is worth the extra copy.
+
+---
+
 ## Memory management
 
 ### Discard already-read data
@@ -238,6 +357,7 @@ The library defines these error classes:
 - `ExtendedBufferError`
 - `ExtendedBufferTypeError`
 - `ExtendedBufferRangeError`
+- `ExtendedBufferUnsupportedError`
 
 Common error codes you may see:
 
@@ -246,8 +366,12 @@ Common error codes you may see:
 - `INVALID_INTEGER_SIZE_VALUE_TYPE`: size is not a safe integer
 - `INVALID_INTEGER_SIZE_VALUE_RANGE`: integer size not in `1…6`
 - `INVALID_INSTANCE_STATE`: internal invariant check failed
+- `INVALID_BUFFER_TYPE`: attempt write invalid buffer type
 - `VALUE_MUST_BE_AN_INTEGER`: value not a safe integer
 - `VALUE_MUST_BE_AN_UNSIGNED_INTEGER`: value is not a safe integer or less than 0
+- `VALUE_MUST_BE_AN_BIG_INTEGER`: value is not a `bigint`
+- `VALUE_MUST_BE_AN_UNSIGNED_BIG_INTEGER`: value is not a `bigint` or less than 0
+- `EXECUTION_ENVIRONMENT_NOT_SUPPORT_BIG_INT`: BigInt methods are not supported in the current runtime
 - `EXCEEDING_MAXIMUM_BUFFER_SIZE`: allocation exceeds Node’s `kMaxLength` or `os.totalmem()`
 
 ---
@@ -281,6 +405,7 @@ Properties:
 Core:
 - `initExtendedBuffer()`, `assertInstanceState()`, `clean()`
 - `nativePointer()`, `getWritableSizeStart()`, `getWritableSizeEnd()`, `getWritableSize()`, `getReadableSize()`
+- `transaction(callback)`
 - `allocStart(size)`, `allocEnd(size)`
 - `writeNativeBuffer(buf, unshift?)`, `writeBuffer(bufOrEB, unshift?)`, `writeString(str, enc?, unshift?)`
 - Pointer: `setPointer(p)`, `getPointer()`, `offset(n)`, `isReadable(size)`
@@ -289,8 +414,14 @@ Core:
 Numbers:
 - Write: `writeIntBE/LE`, `writeUIntBE/LE`, `writeInt8`, `writeUInt8`,
   `writeInt16BE/LE`, `writeUInt16BE/LE`, `writeInt32BE/LE`, `writeUInt32BE/LE`,
+  `writeBigInt64BE/LE`, `writeBigUInt64BE/LE`,
   `writeFloatBE/LE`, `writeDoubleBE/LE`
 - Read: `readBuffer`, `readString`,
   `readIntBE/LE`, `readUIntBE/LE`, `readInt8`, `readUInt8`,
   `readInt16BE/LE`, `readUInt16BE/LE`, `readInt32BE/LE`, `readUInt32BE/LE`,
+  `readBigInt64BE/LE`, `readBigUInt64BE/LE`,
   `readFloatBE/LE`, `readDoubleBE/LE`
+
+## License
+
+MIT

package/dist/ExtendedBuffer.d.ts

@@ -1,5 +1,6 @@
 /// <reference types="node" />
 import type { ExtendedBufferOptions } from './ExtendedBufferOptions';
+import type { ExtendedBufferTransaction } from './ExtendedBufferTransaction';
 export declare class ExtendedBuffer<EBO extends ExtendedBufferOptions = ExtendedBufferOptions> {
     protected _pointer: number;
     protected _pointerEnd: number;
@@ -9,6 +10,7 @@ export declare class ExtendedBuffer<EBO extends ExtendedBufferOptions = Extended
     protected readonly _capacityStep: number;
     protected readonly _nativeAllocSlow?: boolean;
     protected readonly _nativeReallocSlow?: boolean;
+    protected _transaction?: ExtendedBufferTransaction;
     constructor(options?: ExtendedBufferOptions);
     protected createInstanceOptions(options?: ExtendedBufferOptions): ExtendedBufferOptions;
     protected createInstance(options?: EBO): this;
@@ -23,6 +25,7 @@ export declare class ExtendedBuffer<EBO extends ExtendedBufferOptions = Extended
     getWritableSizeStart(): number;
     getWritableSizeEnd(): number;
     getWritableSize(): number;
+    transaction<T>(callback: () => T): T;
     allocStart(size: number): this;
     allocEnd(size: number): this;
     getReadableSize(): number;
@@ -36,6 +39,7 @@ export declare class ExtendedBuffer<EBO extends ExtendedBufferOptions = Extended
     isReadable(size: number): boolean;
     writeBuffer(value: Buffer | ExtendedBuffer<ExtendedBufferOptions>, unshift?: boolean): this;
     writeString(string: string, encoding?: BufferEncoding, unshift?: boolean): this;
+    protected writeIntCommon(method: 'writeIntBE' | 'writeIntLE' | 'writeUIntBE' | 'writeUIntLE', value: number, size: number, unsigned: boolean, unshift?: boolean): this;
     writeIntBE(value: number, size: number, unshift?: boolean): this;
     writeIntLE(value: number, size: number, unshift?: boolean): this;
     writeUIntBE(value: number, size: number, unshift?: boolean): this;
@@ -50,6 +54,12 @@ export declare class ExtendedBuffer<EBO extends ExtendedBufferOptions = Extended
     writeInt32LE(value: number, unshift?: boolean): this;
     writeUInt32BE(value: number, unshift?: boolean): this;
     writeUInt32LE(value: number, unshift?: boolean): this;
+    protected writeBigInt64Common(method: 'writeBigInt64BE' | 'writeBigInt64LE' | 'writeBigUInt64BE' | 'writeBigUInt64LE', value: bigint, unsigned: boolean, unshift?: boolean): this;
+    writeBigInt64BE(value: bigint, unshift?: boolean): this;
+    writeBigInt64LE(value: bigint, unshift?: boolean): this;
+    writeBigUInt64BE(value: bigint, unshift?: boolean): this;
+    writeBigUInt64LE(value: bigint, unshift?: boolean): this;
+    protected writeFloatingPointCommon(method: 'writeFloatBE' | 'writeFloatLE' | 'writeDoubleBE' | 'writeDoubleLE', value: number, size: 4 | 8, unshift?: boolean): this;
     writeFloatBE(value: number, unshift?: boolean): this;
     writeFloatLE(value: number, unshift?: boolean): this;
     writeDoubleBE(value: number, unshift?: boolean): this;
@@ -58,6 +68,7 @@ export declare class ExtendedBuffer<EBO extends ExtendedBufferOptions = Extended
     readBuffer(size: number, asNative: true): Buffer;
     readBuffer(size: number, asNative: false, bufferOptions?: EBO): this;
     readString(size: number, encoding?: BufferEncoding): string;
+    protected readIntCommon(method: 'readIntBE' | 'readIntLE' | 'readUIntBE' | 'readUIntLE', size: number): number;
     readIntBE(size: number): number;
     readIntLE(size: number): number;
     readUIntBE(size: number): number;
@@ -72,6 +83,12 @@ export declare class ExtendedBuffer<EBO extends ExtendedBufferOptions = Extended
     readInt32LE(): number;
     readUInt32BE(): number;
     readUInt32LE(): number;
+    protected readBigInt64Common(method: 'readBigInt64BE' | 'readBigInt64LE' | 'readBigUInt64BE' | 'readBigUInt64LE'): bigint;
+    readBigInt64BE(): bigint;
+    readBigInt64LE(): bigint;
+    readBigUInt64BE(): bigint;
+    readBigUInt64LE(): bigint;
+    protected readFloatingPointCommon(method: 'readFloatBE' | 'readFloatLE' | 'readDoubleBE' | 'readDoubleLE', size: 4 | 8): number;
     readFloatBE(): number;
     readFloatLE(): number;
     readDoubleBE(): number;

package/dist/ExtendedBuffer.js

@@ -105,6 +105,35 @@ class ExtendedBuffer {
     getWritableSize() {
         return this.getWritableSizeStart() + this.getWritableSizeEnd();
     }
+    transaction(callback) {
+        if (this._transaction) {
+            return callback();
+        }
+        this.assertInstanceState();
+        this._transaction = {
+            pointer: this._pointer,
+            pointerEnd: this._pointerEnd,
+            pointerStart: this._pointerStart,
+            nativeBuffer: this._nativeBuffer,
+            nativeBufferLength: this._nativeBuffer.length,
+            nativePayload: buffer_1.Buffer.from(utils.nativeBufferSubarray(this._nativeBuffer, this._pointerStart, this._pointerEnd))
+        };
+        try {
+            return callback();
+        }
+        catch (e) {
+            this._transaction.nativePayload.copy(this._transaction.nativeBuffer, this._transaction.pointerStart);
+            this._nativeBuffer = this._transaction.nativeBuffer;
+            this._pointer = this._transaction.pointer;
+            this._pointerEnd = this._transaction.pointerEnd;
+            this._pointerStart = this._transaction.pointerStart;
+            this.assertInstanceState();
+            throw e;
+        }
+        finally {
+            this._transaction = undefined;
+        }
+    }
     allocStart(size) {
         utils.assertUnsignedInteger(size);
         if (this.getWritableSizeStart() >= size) {
@@ -200,74 +229,49 @@ class ExtendedBuffer {
         if (value instanceof ExtendedBuffer) {
             return this.writeNativeBuffer(value.nativeBufferView, unshift);
         }
-        return this.writeNativeBuffer(value, unshift);
+        if (buffer_1.Buffer.isBuffer(value)) {
+            return this.writeNativeBuffer(value, unshift);
+        }
+        throw new errors_1.ExtendedBufferTypeError('INVALID_BUFFER_TYPE');
     }
     writeString(string, encoding, unshift) {
         const bytes = buffer_1.Buffer.from(string, encoding);
         return this.writeNativeBuffer(bytes, unshift);
     }
-    writeIntBE(value, size, unshift) {
-        utils.assertInteger(value);
-        utils.assertIntegerSize(size);
-        if (unshift) {
-            this.allocStart(size);
-            this._nativeBuffer.writeIntBE(value, this._pointerStart - size, size);
-            this._pointerStart -= size;
+    writeIntCommon(method, value, size, unsigned, unshift) {
+        if (unsigned) {
+            utils.assertUnsignedInteger(value);
         }
         else {
-            this.allocEnd(size);
-            this._nativeBuffer.writeIntBE(value, this._pointerEnd, size);
-            this._pointerEnd += size;
+            utils.assertInteger(value);
         }
-        return this;
-    }
-    writeIntLE(value, size, unshift) {
-        utils.assertInteger(value);
         utils.assertIntegerSize(size);
         if (unshift) {
             this.allocStart(size);
-            this._nativeBuffer.writeIntLE(value, this._pointerStart - size, size);
+            this._nativeBuffer[method](value, this._pointerStart - size, size);
             this._pointerStart -= size;
         }
         else {
             this.allocEnd(size);
-            this._nativeBuffer.writeIntLE(value, this._pointerEnd, size);
+            this._nativeBuffer[method](value, this._pointerEnd, size);
             this._pointerEnd += size;
         }
         return this;
     }
+    writeIntBE(value, size, unshift) {
+        return this.writeIntCommon('writeIntBE', value, size, false, unshift);
+    }
+    writeIntLE(value, size, unshift) {
+        return this.writeIntCommon('writeIntLE', value, size, false, unshift);
+    }
     writeUIntBE(value, size, unshift) {
-        utils.assertUnsignedInteger(value);
-        utils.assertIntegerSize(size);
-        if (unshift) {
-            this.allocStart(size);
-            this._nativeBuffer.writeUIntBE(value, this._pointerStart - size, size);
-            this._pointerStart -= size;
-        }
-        else {
-            this.allocEnd(size);
-            this._nativeBuffer.writeUIntBE(value, this._pointerEnd, size);
-            this._pointerEnd += size;
-        }
-        return this;
+        return this.writeIntCommon('writeUIntBE', value, size, true, unshift);
     }
     writeUIntLE(value, size, unshift) {
-        utils.assertUnsignedInteger(value);
-        utils.assertIntegerSize(size);
-        if (unshift) {
-            this.allocStart(size);
-            this._nativeBuffer.writeUIntLE(value, this._pointerStart - size, size);
-            this._pointerStart -= size;
-        }
-        else {
-            this.allocEnd(size);
-            this._nativeBuffer.writeUIntLE(value, this._pointerEnd, size);
-            this._pointerEnd += size;
-        }
-        return this;
+        return this.writeIntCommon('writeUIntLE', value, size, true, unshift);
     }
     writeInt8(value, unshift) {
-        return this.writeIntBE(value, 1, unshift);
+        return this.writeIntLE(value, 1, unshift);
     }
     writeUInt8(value, unshift) {
         return this.writeUIntLE(value, 1, unshift);
@@ -296,57 +300,63 @@ class ExtendedBuffer {
     writeUInt32LE(value, unshift) {
         return this.writeUIntLE(value, 4, unshift);
     }
-    writeFloatBE(value, unshift) {
-        if (unshift) {
-            this.allocStart(4);
-            this._nativeBuffer.writeFloatBE(value, this._pointerStart - 4);
-            this._pointerStart -= 4;
+    writeBigInt64Common(method, value, unsigned, unshift) {
+        utils.assertSupportBigInteger();
+        if (unsigned) {
+            utils.assertUnsignedBigInteger(value);
         }
         else {
-            this.allocEnd(4);
-            this._nativeBuffer.writeFloatBE(value, this._pointerEnd);
-            this._pointerEnd += 4;
+            utils.assertBigInteger(value);
         }
-        return this;
-    }
-    writeFloatLE(value, unshift) {
+        const size = 8;
         if (unshift) {
-            this.allocStart(4);
-            this._nativeBuffer.writeFloatLE(value, this._pointerStart - 4);
-            this._pointerStart -= 4;
+            this.allocStart(size);
+            this._nativeBuffer[method](value, this._pointerStart - size);
+            this._pointerStart -= size;
         }
         else {
-            this.allocEnd(4);
-            this._nativeBuffer.writeFloatLE(value, this._pointerEnd);
-            this._pointerEnd += 4;
+            this.allocEnd(size);
+            this._nativeBuffer[method](value, this._pointerEnd);
+            this._pointerEnd += size;
         }
         return this;
     }
-    writeDoubleBE(value, unshift) {
+    writeBigInt64BE(value, unshift) {
+        return this.writeBigInt64Common('writeBigInt64BE', value, false, unshift);
+    }
+    writeBigInt64LE(value, unshift) {
+        return this.writeBigInt64Common('writeBigInt64LE', value, false, unshift);
+    }
+    writeBigUInt64BE(value, unshift) {
+        return this.writeBigInt64Common('writeBigUInt64BE', value, true, unshift);
+    }
+    writeBigUInt64LE(value, unshift) {
+        return this.writeBigInt64Common('writeBigUInt64LE', value, true, unshift);
+    }
+    writeFloatingPointCommon(method, value, size, unshift) {
         if (unshift) {
-            this.allocStart(8);
-            this._nativeBuffer.writeDoubleBE(value, this._pointerStart - 8);
-            this._pointerStart -= 8;
+            this.allocStart(size);
+            this._nativeBuffer[method](value, this._pointerStart - size);
+            this._pointerStart -= size;
         }
         else {
-            this.allocEnd(8);
-            this._nativeBuffer.writeDoubleBE(value, this._pointerEnd);
-            this._pointerEnd += 8;
+            this.allocEnd(size);
+            this._nativeBuffer[method](value, this._pointerEnd);
+            this._pointerEnd += size;
         }
         return this;
     }
+    writeFloatBE(value, unshift) {
+        return this.writeFloatingPointCommon('writeFloatBE', value, 4, unshift);
+    }
+    writeFloatLE(value, unshift) {
+        return this.writeFloatingPointCommon('writeFloatLE', value, 4, unshift);
+    }
+    writeDoubleBE(value, unshift) {
+        return this.writeFloatingPointCommon('writeDoubleBE', value, 8, unshift);
+    }
     writeDoubleLE(value, unshift) {
-        if (unshift) {
-            this.allocStart(8);
-            this._nativeBuffer.writeDoubleLE(value, this._pointerStart - 8);
-            this._pointerStart -= 8;
-        }
-        else {
-            this.allocEnd(8);
-            this._nativeBuffer.writeDoubleLE(value, this._pointerEnd);
-            this._pointerEnd += 8;
-        }
-        return this;
+        return this.writeFloatingPointCommon('writeDoubleLE', value, 8, unshift);
     }
     readBuffer(size, asNative, bufferOptions) {
         utils.assertUnsignedInteger(size);
@@ -367,44 +377,29 @@ class ExtendedBuffer {
         this.offset(size);
         return result;
     }
-    readIntBE(size) {
+    readIntCommon(method, 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);
+        const result = this._nativeBuffer[method](this.nativePointer(), size);
         this.offset(size);
         return result;
     }
+    readIntBE(size) {
+        return this.readIntCommon('readIntBE', size);
+    }
     readIntLE(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;
+        return this.readIntCommon('readIntLE', size);
     }
     readUIntBE(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;
+        return this.readIntCommon('readUIntBE', size);
     }
     readUIntLE(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;
+        return this.readIntCommon('readUIntLE', size);
     }
     readInt8() {
-        return this.readIntBE(1);
+        return this.readIntLE(1);
     }
     readUInt8() {
         return this.readUIntLE(1);
@@ -433,41 +428,48 @@ class ExtendedBuffer {
     readUInt32LE() {
         return this.readUIntLE(4);
     }
-    readFloatBE() {
-        const size = 4;
+    readBigInt64Common(method) {
+        utils.assertSupportBigInteger();
+        const size = 8;
         if (!this.isReadable(size)) {
             throw new errors_1.ExtendedBufferRangeError('SIZE_OUT_OF_RANGE');
         }
-        const result = this._nativeBuffer.readFloatBE(this.nativePointer());
+        const result = this._nativeBuffer[method](this.nativePointer());
         this.offset(size);
         return result;
     }
-    readFloatLE() {
-        const size = 4;
+    readBigInt64BE() {
+        return this.readBigInt64Common('readBigInt64BE');
+    }
+    readBigInt64LE() {
+        return this.readBigInt64Common('readBigInt64LE');
+    }
+    readBigUInt64BE() {
+        return this.readBigInt64Common('readBigUInt64BE');
+    }
+    readBigUInt64LE() {
+        return this.readBigInt64Common('readBigUInt64LE');
+    }
+    readFloatingPointCommon(method, size) {
+        utils.assertUnsignedInteger(size);
         if (!this.isReadable(size)) {
             throw new errors_1.ExtendedBufferRangeError('SIZE_OUT_OF_RANGE');
         }
-        const result = this._nativeBuffer.readFloatLE(this.nativePointer());
+        const result = this._nativeBuffer[method](this.nativePointer());
         this.offset(size);
         return result;
     }
+    readFloatBE() {
+        return this.readFloatingPointCommon('readFloatBE', 4);
+    }
+    readFloatLE() {
+        return this.readFloatingPointCommon('readFloatLE', 4);
+    }
     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;
+        return this.readFloatingPointCommon('readDoubleBE', 8);
     }
     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;
+        return this.readFloatingPointCommon('readDoubleLE', 8);
     }
 }
 exports.ExtendedBuffer = ExtendedBuffer;

package/dist/ExtendedBufferTransaction.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="node" />
+export type ExtendedBufferTransaction = {
+    pointer: number;
+    pointerEnd: number;
+    pointerStart: number;
+    nativeBuffer: Buffer;
+    nativePayload: Buffer;
+    nativeBufferLength: number;
+};

package/dist/ExtendedBufferTransaction.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/errors/ExtendedBufferUnsupportedError.d.ts

@@ -0,0 +1,3 @@
+import { ExtendedBufferError } from './ExtendedBufferError';
+export declare class ExtendedBufferUnsupportedError extends ExtendedBufferError {
+}

package/dist/errors/ExtendedBufferUnsupportedError.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExtendedBufferUnsupportedError = void 0;
+const ExtendedBufferError_1 = require("./ExtendedBufferError");
+class ExtendedBufferUnsupportedError extends ExtendedBufferError_1.ExtendedBufferError {
+}
+exports.ExtendedBufferUnsupportedError = ExtendedBufferUnsupportedError;

package/dist/errors/index.d.ts

@@ -1,3 +1,4 @@
 export { ExtendedBufferError } from './ExtendedBufferError';
 export { ExtendedBufferTypeError } from './ExtendedBufferTypeError';
 export { ExtendedBufferRangeError } from './ExtendedBufferRangeError';
+export { ExtendedBufferUnsupportedError } from './ExtendedBufferUnsupportedError';

package/dist/errors/index.js

@@ -1,9 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ExtendedBufferRangeError = exports.ExtendedBufferTypeError = exports.ExtendedBufferError = void 0;
+exports.ExtendedBufferUnsupportedError = exports.ExtendedBufferRangeError = exports.ExtendedBufferTypeError = exports.ExtendedBufferError = void 0;
 var ExtendedBufferError_1 = require("./ExtendedBufferError");
 Object.defineProperty(exports, "ExtendedBufferError", { enumerable: true, get: function () { return ExtendedBufferError_1.ExtendedBufferError; } });
 var ExtendedBufferTypeError_1 = require("./ExtendedBufferTypeError");
 Object.defineProperty(exports, "ExtendedBufferTypeError", { enumerable: true, get: function () { return ExtendedBufferTypeError_1.ExtendedBufferTypeError; } });
 var ExtendedBufferRangeError_1 = require("./ExtendedBufferRangeError");
 Object.defineProperty(exports, "ExtendedBufferRangeError", { enumerable: true, get: function () { return ExtendedBufferRangeError_1.ExtendedBufferRangeError; } });
+var ExtendedBufferUnsupportedError_1 = require("./ExtendedBufferUnsupportedError");
+Object.defineProperty(exports, "ExtendedBufferUnsupportedError", { enumerable: true, get: function () { return ExtendedBufferUnsupportedError_1.ExtendedBufferUnsupportedError; } });

package/dist/index.d.ts

@@ -2,3 +2,4 @@ export * from './utils';
 export * from './errors';
 export { ExtendedBuffer } from './ExtendedBuffer';
 export type { ExtendedBufferOptions } from './ExtendedBufferOptions';
+export type { ExtendedBufferTransaction } from './ExtendedBufferTransaction';

package/dist/utils/assert-big-integer.d.ts

@@ -0,0 +1 @@
+export declare function assertBigInteger(value: bigint): void;

package/dist/utils/assert-big-integer.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertBigInteger = void 0;
+const errors_1 = require("../errors");
+function assertBigInteger(value) {
+    if (typeof value !== 'bigint') {
+        throw new errors_1.ExtendedBufferTypeError('VALUE_MUST_BE_AN_BIG_INTEGER');
+    }
+}
+exports.assertBigInteger = assertBigInteger;

package/dist/utils/assert-support-big-integer.d.ts

@@ -0,0 +1 @@
+export declare function assertSupportBigInteger(): void;

package/dist/utils/assert-support-big-integer.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertSupportBigInteger = void 0;
+const buffer_1 = require("buffer");
+const errors_1 = require("../errors");
+function assertSupportBigInteger() {
+    let isSupported = false;
+    try {
+        isSupported = typeof BigInt(0) === 'bigint';
+    }
+    catch (e) { }
+    if (!isSupported || typeof buffer_1.Buffer.prototype.readBigUInt64LE !== 'function') {
+        throw new errors_1.ExtendedBufferUnsupportedError('EXECUTION_ENVIRONMENT_NOT_SUPPORT_BIG_INT');
+    }
+}
+exports.assertSupportBigInteger = assertSupportBigInteger;

package/dist/utils/assert-unsigned-big-integer.d.ts

@@ -0,0 +1 @@
+export declare function assertUnsignedBigInteger(value: bigint): void;

package/dist/utils/assert-unsigned-big-integer.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertUnsignedBigInteger = void 0;
+const errors_1 = require("../errors");
+function assertUnsignedBigInteger(value) {
+    if (typeof value !== 'bigint' || value < 0) {
+        throw new errors_1.ExtendedBufferTypeError('VALUE_MUST_BE_AN_UNSIGNED_BIG_INTEGER');
+    }
+}
+exports.assertUnsignedBigInteger = assertUnsignedBigInteger;

package/dist/utils/index.d.ts

@@ -1,6 +1,9 @@
 export { assertInteger } from './assert-integer';
+export { assertBigInteger } from './assert-big-integer';
 export { assertIntegerSize } from './assert-integer-size';
 export { allocNativeBuffer } from './alloc-native-buffer';
 export { reallocNativeBuffer } from './realloc-native-buffer';
 export { nativeBufferSubarray } from './native-buffer-subarray';
 export { assertUnsignedInteger } from './assert-unsigned-integer';
+export { assertSupportBigInteger } from './assert-support-big-integer';
+export { assertUnsignedBigInteger } from './assert-unsigned-big-integer';

package/dist/utils/index.js

@@ -1,8 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.assertUnsignedInteger = exports.nativeBufferSubarray = exports.reallocNativeBuffer = exports.allocNativeBuffer = exports.assertIntegerSize = exports.assertInteger = void 0;
+exports.assertUnsignedBigInteger = exports.assertSupportBigInteger = exports.assertUnsignedInteger = exports.nativeBufferSubarray = exports.reallocNativeBuffer = exports.allocNativeBuffer = exports.assertIntegerSize = exports.assertBigInteger = exports.assertInteger = void 0;
 var assert_integer_1 = require("./assert-integer");
 Object.defineProperty(exports, "assertInteger", { enumerable: true, get: function () { return assert_integer_1.assertInteger; } });
+var assert_big_integer_1 = require("./assert-big-integer");
+Object.defineProperty(exports, "assertBigInteger", { enumerable: true, get: function () { return assert_big_integer_1.assertBigInteger; } });
 var assert_integer_size_1 = require("./assert-integer-size");
 Object.defineProperty(exports, "assertIntegerSize", { enumerable: true, get: function () { return assert_integer_size_1.assertIntegerSize; } });
 var alloc_native_buffer_1 = require("./alloc-native-buffer");
@@ -13,3 +15,7 @@ var native_buffer_subarray_1 = require("./native-buffer-subarray");
 Object.defineProperty(exports, "nativeBufferSubarray", { enumerable: true, get: function () { return native_buffer_subarray_1.nativeBufferSubarray; } });
 var assert_unsigned_integer_1 = require("./assert-unsigned-integer");
 Object.defineProperty(exports, "assertUnsignedInteger", { enumerable: true, get: function () { return assert_unsigned_integer_1.assertUnsignedInteger; } });
+var assert_support_big_integer_1 = require("./assert-support-big-integer");
+Object.defineProperty(exports, "assertSupportBigInteger", { enumerable: true, get: function () { return assert_support_big_integer_1.assertSupportBigInteger; } });
+var assert_unsigned_big_integer_1 = require("./assert-unsigned-big-integer");
+Object.defineProperty(exports, "assertUnsignedBigInteger", { enumerable: true, get: function () { return assert_unsigned_big_integer_1.assertUnsignedBigInteger; } });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "extended-buffer",
-  "version": "7.2.1",
+  "version": "7.3.1",
   "description": "Node JS extended Buffer",
   "type": "commonjs",
   "main": "./dist/index.js",
@@ -55,7 +55,7 @@
     "README.md"
   ],
   "devDependencies": {
-    "@types/node": "^6.14.13",
+    "@types/node": "^12.20.55",
     "chai": "^4.5.0",
     "mocha": "^6.2.3",
     "nyc": "^11.9.0",