From eed7b4ee6e57bd00f1139e171f16e2c79aa60f6e Mon Sep 17 00:00:00 2001 From: RedDwarfian Date: Sat, 27 Jul 2019 16:24:22 -0400 Subject: [PATCH 1/6] [Implement] Buffer Handling (U)Int32 --- assembly/buffer/index.ts | 44 ++++++++++++++++++ assembly/node.d.ts | 16 +++++++ tests/buffer.spec.ts | 96 ++++++++++++++++++++++++++++++++++++++++ 3 files changed, 156 insertions(+) diff --git a/assembly/buffer/index.ts b/assembly/buffer/index.ts index fb5d4ca..91db14b 100644 --- a/assembly/buffer/index.ts +++ b/assembly/buffer/index.ts @@ -92,4 +92,48 @@ export class Buffer extends Uint8Array { store(this.dataStart + offset, bswap(value)); return offset + 2; } + + readInt32LE(offset: i32 = 0): i32 { + if(i32(offset < 0) | i32(offset + 4 > this.dataLength)) throw new RangeError(E_INDEXOUTOFRANGE); + return load(this.dataStart + offset); + } + + readInt32BE(offset: i32 = 0): i32 { + if(i32(offset < 0) | i32(offset + 4 > this.dataLength)) throw new RangeError(E_INDEXOUTOFRANGE); + return bswap(load(this.dataStart + offset)); + } + + readUInt32LE(offset: i32 = 0): u32 { + if(i32(offset < 0) | i32(offset + 4 > this.dataLength)) throw new RangeError(E_INDEXOUTOFRANGE); + return load(this.dataStart + offset); + } + + readUInt32BE(offset: i32 = 0): u32 { + if(i32(offset < 0) | i32(offset + 4 > this.dataLength)) throw new RangeError(E_INDEXOUTOFRANGE); + return bswap(load(this.dataStart + offset)); + } + + writeInt32LE(value: i32, offset: i32 = 0): i32 { + if(i32(offset < 0) | i32(offset + 4 > this.dataLength)) throw new RangeError(E_INDEXOUTOFRANGE); + store(this.dataStart + offset, value); + return offset + 4; + } + + writeInt32BE(value: i32, offset: i32 = 0): i32 { + if(i32(offset < 0) | i32(offset + 4 > this.dataLength)) throw new RangeError(E_INDEXOUTOFRANGE); + store(this.dataStart + offset, bswap(value)); + return offset + 4; + } + + writeUInt32LE(value: u32, offset: i32 = 0): i32 { + if(i32(offset < 0) | i32(offset + 4 > this.dataLength)) throw new RangeError(E_INDEXOUTOFRANGE); + store(this.dataStart + offset, value); + return offset + 4; + } + + writeUInt32BE(value: u32, offset: i32 = 0): i32 { + if(i32(offset < 0) | i32(offset + 4 > this.dataLength)) throw new RangeError(E_INDEXOUTOFRANGE); + store(this.dataStart + offset, bswap(value)); + return offset + 4; + } } diff --git a/assembly/node.d.ts b/assembly/node.d.ts index 5beb381..16244e7 100644 --- a/assembly/node.d.ts +++ b/assembly/node.d.ts @@ -29,4 +29,20 @@ declare class Buffer extends Uint8Array { writeUInt16LE(value: u16, offset?: i32): i32; /** Writes an inputted unsigned 16-bit integer at the designated offset, stored in Big Endian format */ writeUInt16BE(value: u16, offset?: i32): i32; + /** Reads a signed 32-bit integer, stored in Little Endian format at the designated offset. */ + readInt32LE(offset?: i32): i32; + /** Reads a signed 32-bit integer, stored in Big Endian format at the designated offset. */ + readInt32BE(offset?: i32): i32; + /** Reads an unsigned 32-bit integer, stored in Little Endian format at the designated offset. */ + readUInt32LE(offset?: i32): u32; + /** Reads an unsigned 32-bit integer, stored in Big Endian format at the designated offset. */ + readUInt32BE(offset?: i32): u32; + /** Writes an inputted 32-bit integer at the designated offset, stored in Little Endian format */ + writeInt32LE(value: i32, offset?: i32): i32; + /** Writes an inputted 32-bit integer at the designated offset, stored in Big Endian format */ + writeInt32BE(value: i32, offset?: i32): i32; + /** Writes an inputted unsigned 32-bit integer at the designated offset, stored in Little Endian format */ + writeUInt32LE(value: u32, offset?: i32): i32; + /** Writes an inputted unsigned 32-bit integer at the designated offset, stored in Big Endian format */ + writeUInt32BE(value: u32, offset?: i32): i32; } diff --git a/tests/buffer.spec.ts b/tests/buffer.spec.ts index ba4ff36..212593f 100644 --- a/tests/buffer.spec.ts +++ b/tests/buffer.spec.ts @@ -213,4 +213,100 @@ describe("buffer", () => { // newBuff.writeUInt16BE(0); // }).toThrow(); }); + + test("#readInt32LE", () => { + let buff = create([0xEF,0xBE,0xAD,0xDE,0x0d,0xc0,0xde,0x10]); + expect(buff.readInt32LE()).toBe(-559038737); + expect(buff.readInt32LE(4)).toBe(283033613); + // TODO: + // expectFn(() => { + // let newBuff = new Buffer(1); + // newBuff.readInt32LE(0); + // }).toThrow(); + }); + + test("#readInt32BE", () => { + let buff = create([0xDE,0xAD,0xBE,0xEF,0x10,0xde,0xc0,0x0d]); + expect(buff.readInt32BE()).toBe(-559038737); + expect(buff.readInt32BE(4)).toBe(283033613); + // TODO: + // expectFn(() => { + // let newBuff = new Buffer(1); + // newBuff.readInt32BE(0); + // }).toThrow(); + }); + + test("#readUInt32LE", () => { + let buff = create([0xEF,0xBE,0xAD,0xDE,0x0d,0xc0,0xde,0x10]); + expect(buff.readUInt32LE()).toBe(3735928559); + expect(buff.readUInt32LE(4)).toBe(283033613); + // TODO: + // expectFn(() => { + // let newBuff = new Buffer(1); + // newBuff.readUInt32LE(0); + // }).toThrow(); + }); + + test("#readUInt32BE", () => { + let buff = create([0xDE,0xAD,0xBE,0xEF,0x10,0xde,0xc0,0x0d]); + expect(buff.readUInt32BE()).toBe(3735928559); + expect(buff.readUInt32BE(4)).toBe(283033613); + // TODO: + // expectFn(() => { + // let newBuff = new Buffer(1); + // newBuff.readUInt32BE(0); + // }).toThrow(); + }); + + test("#writeInt32LE", () => { + let buff = new Buffer(8); + expect(buff.writeInt32LE(3735928559)).toBe(4); + expect(buff.writeInt32LE(283033613,4)).toBe(8); + let result = create([0xEF,0xBE,0xAD,0xDE,0x0d,0xc0,0xde,0x10]); + expect(buff).toStrictEqual(result); + // TODO: + // expectFn(() => { + // let newBuff = new Buffer(1); + // newBuff.writeInt32LE(0); + // }).toThrow(); + }); + + test("#writeInt32BE", () => { + let buff = new Buffer(8); + expect(buff.writeInt32BE(3735928559)).toBe(4); + expect(buff.writeInt32BE(283033613,4)).toBe(8); + let result = create([0xDE,0xAD,0xBE,0xEF,0x10,0xde,0xc0,0x0d]); + expect(buff).toStrictEqual(result); + // TODO: + // expectFn(() => { + // let newBuff = new Buffer(1); + // newBuff.writeInt32BE(0); + // }).toThrow(); + }); + + test("#writeUInt32LE", () => { + let buff = new Buffer(8); + expect(buff.writeUInt32LE(3735928559)).toBe(4); + expect(buff.writeUInt32LE(283033613,4)).toBe(8); + let result = create([0xEF,0xBE,0xAD,0xDE,0x0d,0xc0,0xde,0x10]);; + expect(buff).toStrictEqual(result); + // TODO: + // expectFn(() => { + // let newBuff = new Buffer(1); + // newBuff.writeUInt32LE(0); + // }).toThrow(); + }); + + test("#writeUInt32BE", () => { + let buff = new Buffer(8); + expect(buff.writeUInt32BE(3735928559)).toBe(4); + expect(buff.writeUInt32BE(283033613,4)).toBe(8); + let result = create([0xDE,0xAD,0xBE,0xEF,0x10,0xde,0xc0,0x0d]); + expect(buff).toStrictEqual(result); + // TODO: + // expectFn(() => { + // let newBuff = new Buffer(1); + // newBuff.writeUInt32BE(0); + // }).toThrow(); + }); }); From e9e95549de5e05df1a731e169e1639aaacabeefc Mon Sep 17 00:00:00 2001 From: RedDwarfian Date: Sat, 27 Jul 2019 18:54:49 -0400 Subject: [PATCH 2/6] [Cleanup] Actually using signed int 32, now. --- tests/buffer.spec.ts | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/tests/buffer.spec.ts b/tests/buffer.spec.ts index 212593f..83131af 100644 --- a/tests/buffer.spec.ts +++ b/tests/buffer.spec.ts @@ -260,7 +260,7 @@ describe("buffer", () => { test("#writeInt32LE", () => { let buff = new Buffer(8); - expect(buff.writeInt32LE(3735928559)).toBe(4); + expect(buff.writeInt32LE(-559038737)).toBe(4); expect(buff.writeInt32LE(283033613,4)).toBe(8); let result = create([0xEF,0xBE,0xAD,0xDE,0x0d,0xc0,0xde,0x10]); expect(buff).toStrictEqual(result); @@ -273,7 +273,7 @@ describe("buffer", () => { test("#writeInt32BE", () => { let buff = new Buffer(8); - expect(buff.writeInt32BE(3735928559)).toBe(4); + expect(buff.writeInt32BE(-559038737)).toBe(4); expect(buff.writeInt32BE(283033613,4)).toBe(8); let result = create([0xDE,0xAD,0xBE,0xEF,0x10,0xde,0xc0,0x0d]); expect(buff).toStrictEqual(result); From 2963ee6eae0a29ca41b98354ddbb8eff5c4bff60 Mon Sep 17 00:00:00 2001 From: RedDwarfian Date: Sat, 27 Jul 2019 20:07:14 -0400 Subject: [PATCH 3/6] [Implement] Buffer Handling Float --- assembly/buffer/index.ts | 22 ++++++++++++++++++ assembly/node.d.ts | 8 +++++++ tests/buffer.spec.ts | 48 ++++++++++++++++++++++++++++++++++++++++ 3 files changed, 78 insertions(+) diff --git a/assembly/buffer/index.ts b/assembly/buffer/index.ts index 91db14b..7973028 100644 --- a/assembly/buffer/index.ts +++ b/assembly/buffer/index.ts @@ -136,4 +136,26 @@ export class Buffer extends Uint8Array { store(this.dataStart + offset, bswap(value)); return offset + 4; } + + readFloatLE(offset: i32 = 0): f32 { + if(i32(offset < 0) | i32(offset + 4 > this.dataLength)) throw new RangeError(E_INDEXOUTOFRANGE); + return reinterpret(load(this.dataStart + offset)); + } + + readFloatBE(offset: i32 = 0): f32 { + if(i32(offset < 0) | i32(offset + 4 > this.dataLength)) throw new RangeError(E_INDEXOUTOFRANGE); + return reinterpret(bswap(load(this.dataStart + offset))); + } + + writeFloatLE(value: f32, offset: i32 = 0): i32 { + if(i32(offset < 0) | i32(offset + 4 > this.dataLength)) throw new RangeError(E_INDEXOUTOFRANGE); + store(this.dataStart + offset, reinterpret(value)); + return offset + 4; + } + + writeFloatBE(value: f32, offset: i32 = 0): i32 { + if(i32(offset < 0) | i32(offset + 4 > this.dataLength)) throw new RangeError(E_INDEXOUTOFRANGE); + store(this.dataStart + offset, bswap(reinterpret(value))); + return offset + 4; + } } diff --git a/assembly/node.d.ts b/assembly/node.d.ts index 16244e7..7e4267a 100644 --- a/assembly/node.d.ts +++ b/assembly/node.d.ts @@ -45,4 +45,12 @@ declare class Buffer extends Uint8Array { writeUInt32LE(value: u32, offset?: i32): i32; /** Writes an inputted unsigned 32-bit integer at the designated offset, stored in Big Endian format */ writeUInt32BE(value: u32, offset?: i32): i32; + /** Reads a signed 32-bit float, stored in Little Endian format at the designated offset. */ + readFloatLE(offset?: i32): f32; + /** Reads a signed 32-bit float, stored in Big Endian format at the designated offset. */ + readFloatBE(offset?: i32): f32; + /** Writes an inputted 32-bit float at the designated offset, stored in Little Endian format */ + writeInt32LE(value: f32, offset?: i32): i32; + /** Writes an inputted 32-bit float at the designated offset, stored in Big Endian format */ + writeInt32BE(value: f32, offset?: i32): i32; } diff --git a/tests/buffer.spec.ts b/tests/buffer.spec.ts index 83131af..25aa89c 100644 --- a/tests/buffer.spec.ts +++ b/tests/buffer.spec.ts @@ -309,4 +309,52 @@ describe("buffer", () => { // newBuff.writeUInt32BE(0); // }).toThrow(); }); + + test("#readFloatLE", () => { + let buff = create([0xbb,0xfe,0x4a,0x4f,0x01,0x02,0x03,0x04]); + expect(buff.readFloatLE()).toBe(0xcafebabe); + expect(buff.readFloatLE(4)).toBe(1.539989614439558e-36); + // TODO: + // expectFn(() => { + // let newBuff = new Buffer(1); + // newBuff.readFloatLE(0); + // }).toThrow(); + }); + + test("#readFloatBE", () => { + let buff = create([0x4f,0x4a,0xfe,0xbb,0x01,0x02,0x03,0x04]); + expect(buff.readFloatBE()).toBe(0xcafebabe); + expect(buff.readFloatBE(4)).toBe(2.387939260590663e-38); + // TODO: + // expectFn(() => { + // let newBuff = new Buffer(1); + // newBuff.readFloatBE(0); + // }).toThrow(); + }); + + test("#writeFloatLE", () => { + let buff = new Buffer(8); + expect(buff.writeFloatLE(0xcafebabe)).toBe(4); + expect(buff.writeFloatLE(1.539989614439558e-36,4)).toBe(8); + let result = create([0xbb,0xfe,0x4a,0x4f,0x01,0x02,0x03,0x04]); + expect(buff).toStrictEqual(result); + // TODO: + // expectFn(() => { + // let newBuff = new Buffer(1); + // newBuff.writeFloatLE(0); + // }).toThrow(); + }); + + test("#writeFloatBE", () => { + let buff = new Buffer(8); + expect(buff.writeFloatBE(0xcafebabe)).toBe(4); + expect(buff.writeFloatBE(2.387939260590663e-38,4)).toBe(8); + let result = create([0x4f,0x4a,0xfe,0xbb,0x01,0x02,0x03,0x04]); + expect(buff).toStrictEqual(result); + // TODO: + // expectFn(() => { + // let newBuff = new Buffer(1); + // newBuff.writeFloatBE(0); + // }).toThrow(); + }); }); From cb39f2ea9783ab269530d7aca8041868e1694aef Mon Sep 17 00:00:00 2001 From: RedDwarfian Date: Sun, 28 Jul 2019 02:03:52 -0400 Subject: [PATCH 4/6] [Bug] Copy-Paste Issue --- assembly/node.d.ts | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/assembly/node.d.ts b/assembly/node.d.ts index 7e4267a..0a59c6a 100644 --- a/assembly/node.d.ts +++ b/assembly/node.d.ts @@ -50,7 +50,7 @@ declare class Buffer extends Uint8Array { /** Reads a signed 32-bit float, stored in Big Endian format at the designated offset. */ readFloatBE(offset?: i32): f32; /** Writes an inputted 32-bit float at the designated offset, stored in Little Endian format */ - writeInt32LE(value: f32, offset?: i32): i32; + writeFloatLE(value: f32, offset?: i32): i32; /** Writes an inputted 32-bit float at the designated offset, stored in Big Endian format */ - writeInt32BE(value: f32, offset?: i32): i32; + writeFloatBE(value: f32, offset?: i32): i32; } From 5bcc8ea384a5142c346e6080a87aceb81dfe1ab2 Mon Sep 17 00:00:00 2001 From: RedDwarfian Date: Wed, 31 Jul 2019 23:29:24 -0400 Subject: [PATCH 5/6] [Cleanup] Simplified load and store for LE Floats --- assembly/buffer/index.ts | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/assembly/buffer/index.ts b/assembly/buffer/index.ts index 7973028..da655a3 100644 --- a/assembly/buffer/index.ts +++ b/assembly/buffer/index.ts @@ -139,7 +139,7 @@ export class Buffer extends Uint8Array { readFloatLE(offset: i32 = 0): f32 { if(i32(offset < 0) | i32(offset + 4 > this.dataLength)) throw new RangeError(E_INDEXOUTOFRANGE); - return reinterpret(load(this.dataStart + offset)); + return load(this.dataStart + offset); } readFloatBE(offset: i32 = 0): f32 { @@ -149,7 +149,7 @@ export class Buffer extends Uint8Array { writeFloatLE(value: f32, offset: i32 = 0): i32 { if(i32(offset < 0) | i32(offset + 4 > this.dataLength)) throw new RangeError(E_INDEXOUTOFRANGE); - store(this.dataStart + offset, reinterpret(value)); + store(this.dataStart + offset, value); return offset + 4; } From 29f5b4cb5f00d42c87373e52fdd9e3d4f5b87966 Mon Sep 17 00:00:00 2001 From: jtenner Date: Tue, 6 Aug 2019 10:00:51 -0400 Subject: [PATCH 6/6] [Chore] fix space between if keywords --- assembly/buffer/index.ts | 48 ++++++++++++++++++++-------------------- 1 file changed, 24 insertions(+), 24 deletions(-) diff --git a/assembly/buffer/index.ts b/assembly/buffer/index.ts index d2fb6c3..ce4b27f 100644 --- a/assembly/buffer/index.ts +++ b/assembly/buffer/index.ts @@ -41,133 +41,133 @@ export class Buffer extends Uint8Array { } readInt8(offset: i32 = 0): i8 { - if(i32(offset < 0) | i32(offset >= this.dataLength)) throw new RangeError(E_INDEXOUTOFRANGE); + if (i32(offset < 0) | i32(offset >= this.dataLength)) throw new RangeError(E_INDEXOUTOFRANGE); return load(this.dataStart + offset); } readUInt8(offset: i32 = 0): u8 { - if(i32(offset < 0) | i32(offset >= this.dataLength)) throw new RangeError(E_INDEXOUTOFRANGE); + if (i32(offset < 0) | i32(offset >= this.dataLength)) throw new RangeError(E_INDEXOUTOFRANGE); return load(this.dataStart + offset); } writeInt8(value: i8, offset: i32 = 0): i32 { - if(i32(offset < 0) | i32(offset >= this.dataLength)) throw new RangeError(E_INDEXOUTOFRANGE); + if (i32(offset < 0) | i32(offset >= this.dataLength)) throw new RangeError(E_INDEXOUTOFRANGE); store(this.dataStart + offset, value); return offset + 1; } writeUInt8(value: u8, offset: i32 = 0): i32 { - if(i32(offset < 0) | i32(offset >= this.dataLength)) throw new RangeError(E_INDEXOUTOFRANGE); + if (i32(offset < 0) | i32(offset >= this.dataLength)) throw new RangeError(E_INDEXOUTOFRANGE); store(this.dataStart + offset, value); return offset + 1; } readInt16LE(offset: i32 = 0): i16 { - if(i32(offset < 0) | i32(offset + 2 > this.dataLength)) throw new RangeError(E_INDEXOUTOFRANGE); + if (i32(offset < 0) | i32(offset + 2 > this.dataLength)) throw new RangeError(E_INDEXOUTOFRANGE); return load(this.dataStart + offset); } readInt16BE(offset: i32 = 0): i16 { - if(i32(offset < 0) | i32(offset + 2 > this.dataLength)) throw new RangeError(E_INDEXOUTOFRANGE); + if (i32(offset < 0) | i32(offset + 2 > this.dataLength)) throw new RangeError(E_INDEXOUTOFRANGE); return bswap(load(this.dataStart + offset)); } readUInt16LE(offset: i32 = 0): u16 { - if(i32(offset < 0) | i32(offset + 2 > this.dataLength)) throw new RangeError(E_INDEXOUTOFRANGE); + if (i32(offset < 0) | i32(offset + 2 > this.dataLength)) throw new RangeError(E_INDEXOUTOFRANGE); return load(this.dataStart + offset); } readUInt16BE(offset: i32 = 0): u16 { - if(i32(offset < 0) | i32(offset + 2 > this.dataLength)) throw new RangeError(E_INDEXOUTOFRANGE); + if (i32(offset < 0) | i32(offset + 2 > this.dataLength)) throw new RangeError(E_INDEXOUTOFRANGE); return bswap(load(this.dataStart + offset)); } writeInt16LE(value: i16, offset: i32 = 0): i32 { - if(i32(offset < 0) | i32(offset + 2 > this.dataLength)) throw new RangeError(E_INDEXOUTOFRANGE); + if (i32(offset < 0) | i32(offset + 2 > this.dataLength)) throw new RangeError(E_INDEXOUTOFRANGE); store(this.dataStart + offset, value); return offset + 2; } writeInt16BE(value: i16, offset: i32 = 0): i32 { - if(i32(offset < 0) | i32(offset + 2 > this.dataLength)) throw new RangeError(E_INDEXOUTOFRANGE); + if (i32(offset < 0) | i32(offset + 2 > this.dataLength)) throw new RangeError(E_INDEXOUTOFRANGE); store(this.dataStart + offset, bswap(value)); return offset + 2; } writeUInt16LE(value: u16, offset: i32 = 0): i32 { - if(i32(offset < 0) | i32(offset + 2 > this.dataLength)) throw new RangeError(E_INDEXOUTOFRANGE); + if (i32(offset < 0) | i32(offset + 2 > this.dataLength)) throw new RangeError(E_INDEXOUTOFRANGE); store(this.dataStart + offset, value); return offset + 2; } writeUInt16BE(value: u16, offset: i32 = 0): i32 { - if(i32(offset < 0) | i32(offset + 2 > this.dataLength)) throw new RangeError(E_INDEXOUTOFRANGE); + if (i32(offset < 0) | i32(offset + 2 > this.dataLength)) throw new RangeError(E_INDEXOUTOFRANGE); store(this.dataStart + offset, bswap(value)); return offset + 2; } readInt32LE(offset: i32 = 0): i32 { - if(i32(offset < 0) | i32(offset + 4 > this.dataLength)) throw new RangeError(E_INDEXOUTOFRANGE); + if (i32(offset < 0) | i32(offset + 4 > this.dataLength)) throw new RangeError(E_INDEXOUTOFRANGE); return load(this.dataStart + offset); } readInt32BE(offset: i32 = 0): i32 { - if(i32(offset < 0) | i32(offset + 4 > this.dataLength)) throw new RangeError(E_INDEXOUTOFRANGE); + if (i32(offset < 0) | i32(offset + 4 > this.dataLength)) throw new RangeError(E_INDEXOUTOFRANGE); return bswap(load(this.dataStart + offset)); } readUInt32LE(offset: i32 = 0): u32 { - if(i32(offset < 0) | i32(offset + 4 > this.dataLength)) throw new RangeError(E_INDEXOUTOFRANGE); + if (i32(offset < 0) | i32(offset + 4 > this.dataLength)) throw new RangeError(E_INDEXOUTOFRANGE); return load(this.dataStart + offset); } readUInt32BE(offset: i32 = 0): u32 { - if(i32(offset < 0) | i32(offset + 4 > this.dataLength)) throw new RangeError(E_INDEXOUTOFRANGE); + if (i32(offset < 0) | i32(offset + 4 > this.dataLength)) throw new RangeError(E_INDEXOUTOFRANGE); return bswap(load(this.dataStart + offset)); } writeInt32LE(value: i32, offset: i32 = 0): i32 { - if(i32(offset < 0) | i32(offset + 4 > this.dataLength)) throw new RangeError(E_INDEXOUTOFRANGE); + if (i32(offset < 0) | i32(offset + 4 > this.dataLength)) throw new RangeError(E_INDEXOUTOFRANGE); store(this.dataStart + offset, value); return offset + 4; } writeInt32BE(value: i32, offset: i32 = 0): i32 { - if(i32(offset < 0) | i32(offset + 4 > this.dataLength)) throw new RangeError(E_INDEXOUTOFRANGE); + if (i32(offset < 0) | i32(offset + 4 > this.dataLength)) throw new RangeError(E_INDEXOUTOFRANGE); store(this.dataStart + offset, bswap(value)); return offset + 4; } writeUInt32LE(value: u32, offset: i32 = 0): i32 { - if(i32(offset < 0) | i32(offset + 4 > this.dataLength)) throw new RangeError(E_INDEXOUTOFRANGE); + if (i32(offset < 0) | i32(offset + 4 > this.dataLength)) throw new RangeError(E_INDEXOUTOFRANGE); store(this.dataStart + offset, value); return offset + 4; } writeUInt32BE(value: u32, offset: i32 = 0): i32 { - if(i32(offset < 0) | i32(offset + 4 > this.dataLength)) throw new RangeError(E_INDEXOUTOFRANGE); + if (i32(offset < 0) | i32(offset + 4 > this.dataLength)) throw new RangeError(E_INDEXOUTOFRANGE); store(this.dataStart + offset, bswap(value)); return offset + 4; } readFloatLE(offset: i32 = 0): f32 { - if(i32(offset < 0) | i32(offset + 4 > this.dataLength)) throw new RangeError(E_INDEXOUTOFRANGE); + if (i32(offset < 0) | i32(offset + 4 > this.dataLength)) throw new RangeError(E_INDEXOUTOFRANGE); return load(this.dataStart + offset); } readFloatBE(offset: i32 = 0): f32 { - if(i32(offset < 0) | i32(offset + 4 > this.dataLength)) throw new RangeError(E_INDEXOUTOFRANGE); + if (i32(offset < 0) | i32(offset + 4 > this.dataLength)) throw new RangeError(E_INDEXOUTOFRANGE); return reinterpret(bswap(load(this.dataStart + offset))); } writeFloatLE(value: f32, offset: i32 = 0): i32 { - if(i32(offset < 0) | i32(offset + 4 > this.dataLength)) throw new RangeError(E_INDEXOUTOFRANGE); + if (i32(offset < 0) | i32(offset + 4 > this.dataLength)) throw new RangeError(E_INDEXOUTOFRANGE); store(this.dataStart + offset, value); return offset + 4; } writeFloatBE(value: f32, offset: i32 = 0): i32 { - if(i32(offset < 0) | i32(offset + 4 > this.dataLength)) throw new RangeError(E_INDEXOUTOFRANGE); + if (i32(offset < 0) | i32(offset + 4 > this.dataLength)) throw new RangeError(E_INDEXOUTOFRANGE); store(this.dataStart + offset, bswap(reinterpret(value))); return offset + 4; }