binutils64 0.1.4 → 0.3.0

package/.claude/skills/add-binary-type/SKILL.md

@@ -1,93 +0,0 @@
----
-name: add-binary-type
-description: Add a new matched Read/Write method pair to binutils.js following the library's exact ES5 conventions, then update README.md and add a round-trip test. Use when asked to support a new numeric/binary type (e.g. a new width, a string type, a boolean) in the BinaryReader/BinaryWriter classes.
----
-
-# Adding a binary type to binutils64
-
-This library exposes mirrored methods on `BinaryReader` and `BinaryWriter` in the
-single file `binutils.js`. Every supported type has a `ReadX` and a matching
-`WriteX`. Adding a type means editing both prototypes, updating `README.md`, and
-adding a round-trip test. Follow the templates below **exactly** — style
-deviations and width mismatches are the main source of bugs here (this library
-previously shipped a low-32-bit width bug in the 64-bit writers — don't repeat it).
-
-## Hard rules (match existing code)
-
-- ES5 only: `var`, prototype assignment. No `let`/`const`/classes/arrow functions.
-- Method names are `PascalCase`: `ReadUInt24`, `WriteBool`, etc.
-- Parameters are prefixed `p_` (`p_Value`); locals are prefixed `s_` (`s_Val`,
-  `s_TempBuffer`).
-- Keep `new Buffer(...)` — the package targets `node >=0.12`. Do not switch to
-  `Buffer.alloc`/`Buffer.from` unless `package.json` `engines.node` is also raised.
-- **The write width MUST equal the read width.** When the type is wider than 32
-  bits, use the correct wide Buffer method (`writeBigUInt64LE`, etc.), NOT
-  `writeUInt32LE` — using a 32-bit write into an 8-byte buffer was the original
-  64-bit writer bug (now fixed). 64-bit values are `BigInt`; coerce with
-  `BigInt(p_Value)` so both `Number` and `BigInt` arguments work.
-
-## Reader method template
-
-Out-of-range reads return `0` (or `0.0` / empty `Buffer`) — they do not throw.
-Reads are destructive: slice the consumed bytes off `this.ByteBuffer` and advance
-`this.Position` by the byte width `N`.
-
-```javascript
-ReadTYPE: function() {
-    if (this.ByteBuffer.length < N) {
-        return 0;
-    }
-
-    var s_Val = (this.Endianness == 'little') ? this.ByteBuffer.readTYPELE(0) : this.ByteBuffer.readTYPEBE(0);
-    this.ByteBuffer = this.ByteBuffer.slice(N);
-    this.Position += N;
-    return s_Val;
-},
-```
-
-For a single-byte type there is no endianness branch (see `ReadUInt8`/`ReadInt8`),
-and use `++this.Position;`.
-
-## Writer method template
-
-Allocate an `N`-byte temp buffer, write with the correct-width method honoring
-endianness, grow `this.Length` by `N`, and concat.
-
-```javascript
-WriteTYPE: function(p_Value) {
-    var s_TempBuffer = new Buffer(N);
-    if (this.Endianness == 'little') {
-        s_TempBuffer.writeTYPELE(p_Value, 0);
-    } else {
-        s_TempBuffer.writeTYPEBE(p_Value, 0);
-    }
-    this.Length += N;
-    this.ByteBuffer = Buffer.concat([this.ByteBuffer, s_TempBuffer], this.Length);
-},
-```
-
-For a single-byte type, drop the endianness branch (see `WriteUInt8`/`WriteInt8`).
-
-## Placement
-
-Keep the read/write methods grouped by family and ordered as in the existing file
-(unsigned ascending width, then signed ascending width, then float/double, then
-bytes). Add the new method next to its siblings, not at the end.
-
-## After editing binutils.js
-
-1. **README.md** — add a `### ReadX(...)` and `### WriteX(value)` entry in the
-   matching BinaryReader / BinaryWriter sections, mirroring the existing phrasing
-   ("Reads/Writes a … and advances the current position by N bytes").
-2. **Test** — add a round-trip test (see the `test-binutils` skill): write a value
-   in both `'big'` and `'little'`, read it back, assert equality. Include a min/max
-   or negative boundary value for signed/wide types. For 64-bit values assert the
-   returned type is `bigint`.
-3. Run the tests: `node --test`.
-
-## Verify before finishing
-
-- Write width == read width (round-trip test passes for both endiannesses).
-- `Position`/`Length` advance by exactly `N`.
-- Out-of-range read returns the documented zero value, not a throw.
-- README entries added; method placed beside its family.

package/.claude/skills/test-binutils/SKILL.md

@@ -1,91 +0,0 @@
----
-name: test-binutils
-description: Author and run tests for the binutils64 library using node:test and node:assert. Use when asked to add test coverage, write tests for a Read/Write method, verify a change, or set up the test suite for this project.
----
-
-# Testing binutils64
-
-The library ships with no test framework today. Use the built-in `node:test`
-runner + `node:assert/strict` — zero dependencies. (The library's runtime floor
-stays `node >=0.12`; `node:test` only affects the dev/test environment, which
-needs Node >= 18.)
-
-## Layout & running
-
-- Put tests in `test/`, named `*.test.js`.
-- Run the whole suite: `node --test`.
-- Add to `package.json` if missing:
-  ```json
-  "scripts": { "test": "node --test" }
-  ```
-
-## Test file skeleton
-
-```javascript
-var test = require('node:test');
-var assert = require('node:assert/strict');
-var binutils = require('../binutils.js');
-
-test('UInt32 round-trips both endiannesses', function() {
-    ['big', 'little'].forEach(function(endian) {
-        var w = new binutils.BinaryWriter(endian);
-        w.WriteUInt32(0xDEADBEEF);
-        var r = new binutils.BinaryReader(w.ByteBuffer, endian);
-        assert.equal(r.ReadUInt32(), 0xDEADBEEF);
-    });
-});
-```
-
-Keep test code ES5-compatible in spirit (`var`, `function`) to match repo style,
-though the test runner itself requires modern Node.
-
-## Coverage priorities (highest value first)
-
-### 1. Round-trips — write then read back
-For every type, both `'big'` and `'little'`: write a value, feed `writer.ByteBuffer`
-into a reader, assert the read value equals the written one.
-- `UInt8/16/32`, `Int8/16/32`, `Float`, `Double`, `Bytes`.
-- `UInt64/Int64`: assert against the correct BigInt value. The writers accept a
-  `Number` or a `BigInt` and emit all 8 bytes; the reader returns a `BigInt`, so
-  compare against a `BigInt` literal (`123n`), not a `Number` (`123n !== 123` under
-  strict equality).
-- Signed boundaries: `Int32` min `-2147483648` and max `2147483647`, negatives for
-  `Int8/16`.
-- `Float`: compare with tolerance (`assert.ok(Math.abs(got - want) < 1e-6)`) due to
-  precision loss. `Double` is exact for representable values.
-
-### 2. BinaryReader behavior
-- **Endianness**: identical bytes read as `'big'` vs `'little'` produce the expected
-  swapped values; default (no arg) is `'big'`.
-- **Invariants**: after reads, `Position` advanced by the right byte count, `Length`
-  unchanged at the original size, `ByteBuffer` shrank by the consumed bytes.
-- **Out-of-range** reads return `0` / `0.0` / empty `Buffer` (never throw) — read
-  past the end for each method.
-- **Constructor inputs**: `Buffer`, `Array`, and `string` (+ encoding) all build;
-  an invalid input (e.g. a number) throws.
-- **Constructor copies input**: mutate the caller's original buffer after
-  constructing and confirm reader output is unaffected.
-- `ReadUInt64`/`ReadInt64` return a `bigint` (`assert.equal(typeof v, 'bigint')`).
-- README reader example: bytes `[1,0,2,0,0,0,3,1,2,3,4,5,6]` yield `1`, `2`, `3`,
-  a 6-byte buffer, then `Position` and `Length` both `13`.
-
-### 3. BinaryWriter behavior
-- Defaults: endianness `'big'`, encoding `'ascii'`.
-- `Length` increments by the correct width per write; emitted bytes match expected
-  hex for both endiannesses.
-- `WriteBytes` accepts `string`, `Array`, and `Buffer`, producing identical bytes,
-  and throws on any other input type.
-- README writer example yields `<Buffer ff ff 00 00 00 00 ff ff ff ff 05 04 03 02 01>`,
-  `Length` 15.
-
-### 4. Maintaining bug-documentation tests
-There are no open known bugs at the moment. When you discover one, pin its current
-behavior with a clearly-commented test so regressions are noticed. When a bug is
-fixed, delete its pinned test and convert any matching TODO round-trip into a normal
-assertion — this is how the former 64-bit writer bug (low-32-bit truncation) and the
-`WriteBytes` guard bug (`!p_Value instanceof Buffer` mis-parsing, which let invalid
-input through) were retired.
-
-## Verify before finishing
-- `node --test` passes (except intentionally-`todo` bug tests).
-- New types added via the `add-binary-type` skill have a matching round-trip test.

package/.github/workflows/test.yml

@@ -1,22 +0,0 @@
-name: Tests
-
-on:
-  push:
-    branches: [master]
-  pull_request:
-
-jobs:
-  test:
-    runs-on: ubuntu-latest
-    strategy:
-      fail-fast: false
-      matrix:
-        node: [20, 22, 24]
-    name: Node ${{ matrix.node }}
-    steps:
-      - uses: actions/checkout@v6
-      - uses: actions/setup-node@v6
-        with:
-          node-version: ${{ matrix.node }}
-      # No install step: the package has zero dependencies and no lockfile.
-      - run: npm test

package/CLAUDE.md

@@ -1,54 +0,0 @@
-# CLAUDE.md
-
-Guidance for working in this repository.
-
-## What this is
-
-`binutils64` — a small npm package providing .NET-style `BinaryReader` and
-`BinaryWriter` classes for Node.js, with selectable endianness (`'big'` default
-or `'little'`). All logic lives in a single file: `binutils.js`. Published to npm
-as `binutils64`.
-
-## Layout
-
-- `binutils.js` — the entire library. Two ES5 prototype-based "classes"
-  (`BinaryReader`, `BinaryWriter`) exported via `module.exports`.
-- `README.md` — the public API reference (keep in sync when adding/changing methods).
-- No `src/`, no build step, no dependencies, no test suite.
-
-## Running / testing
-
-There is no test framework, lint config, or build. To verify a change, write an
-ad-hoc script and run it with node, e.g.:
-
-```bash
-node -e "var b=require('./binutils.js'); var w=new b.BinaryWriter('little'); w.WriteUInt32(3); console.log(w.ByteBuffer);"
-```
-
-When you add or change a public method, update the matching section in `README.md`.
-
-## Code conventions (match the existing style exactly)
-
-- ES5 only: `var`, prototype assignment, no classes/arrow functions/`let`/`const`.
-- Method and property names are `PascalCase` (`ReadUInt32`, `ByteBuffer`, `Position`).
-- Function parameters are prefixed `p_` (`p_InputBuffer`, `p_Value`).
-- Local variables are prefixed `s_` (`s_Val`, `s_TempBuffer`).
-- Targets `node >=0.12`, so `new Buffer(...)` is used deliberately despite being
-  deprecated in modern Node. Don't "fix" it to `Buffer.alloc`/`Buffer.from` unless
-  the engines floor is also raised.
-- Commit messages are short, lowercase, imperative (e.g. `add read/write 64 bit values`,
-  `fix read int64`). No AI/Claude attribution.
-
-## Behavior to preserve
-
-- **Reads are destructive.** Each `Read*` slices the consumed bytes off
-  `this.ByteBuffer` and advances `this.Position`. `Length` stays at the original
-  buffer length; `ByteBuffer` shrinks as you read.
-- **Out-of-range reads return `0` (or `0.0`/empty Buffer), they do not throw.**
-- `ReadUInt64`/`ReadInt64` return a `BigInt` (via `readBigUInt64*`/`readBigInt64*`).
-- The constructor copies the input buffer (`new Buffer(p_InputBuffer)`) so the
-  caller's buffer is not mutated — preserve this.
-- `WriteUInt64`/`WriteInt64` accept a `Number` or `BigInt` (coerced via
-  `BigInt(p_Value)`) and emit all 8 bytes via `writeBigUInt64*`/`writeBigInt64*`.
-- `WriteBytes` accepts a `Buffer`, `Array`, or `string`, and throws on any other
-  input type.

package/test/edge-cases.test.js

@@ -1,76 +0,0 @@
-var test = require('node:test');
-var assert = require('node:assert/strict');
-var binutils = require('../binutils.js');
-var BinaryReader = binutils.BinaryReader;
-
-test('constructor accepts a Buffer', function() {
-    var r = new BinaryReader(Buffer.from([1, 2, 3]));
-    assert.equal(r.Length, 3);
-    assert.equal(r.ReadUInt8(), 1);
-});
-
-test('constructor accepts an Array', function() {
-    var r = new BinaryReader([1, 2, 3]);
-    assert.equal(r.Length, 3);
-    assert.equal(r.ReadUInt8(), 1);
-});
-
-test('constructor accepts a string with encoding', function() {
-    var r = new BinaryReader('ABC', 'big', 'ascii');
-    assert.equal(r.Length, 3);
-    assert.equal(r.ReadUInt8(), 65);
-});
-
-test('constructor rejects invalid input types', function() {
-    assert.throws(function() { new BinaryReader(42); }, /Invalid buffer input/);
-    assert.throws(function() { new BinaryReader({}); }, /Invalid buffer input/);
-    assert.throws(function() { new BinaryReader(null); }, /Invalid buffer input/);
-});
-
-test('constructor copies the input buffer (no aliasing)', function() {
-    var src = Buffer.from([1, 2, 3]);
-    var r = new BinaryReader(src);
-    src[0] = 99; // mutate the caller's buffer after construction
-    assert.equal(r.ReadUInt8(), 1, 'reader is unaffected by later mutation of the source');
-});
-
-test('out-of-range integer reads return 0 without advancing Position', function() {
-    var r = new BinaryReader([0x01], 'big'); // only 1 byte available
-    assert.equal(r.ReadUInt16(), 0);
-    assert.equal(r.ReadUInt32(), 0);
-    assert.equal(r.ReadUInt64(), 0);
-    assert.equal(r.ReadInt16(), 0);
-    assert.equal(r.ReadInt32(), 0);
-    assert.equal(r.ReadInt64(), 0);
-    assert.equal(r.Position, 0, 'failed reads do not advance Position');
-    assert.equal(r.ByteBuffer.length, 1, 'failed reads do not consume bytes');
-});
-
-test('out-of-range float/double reads return 0', function() {
-    var r = new BinaryReader([0x01], 'big');
-    assert.equal(r.ReadFloat(), 0);
-    assert.equal(r.ReadDouble(), 0);
-});
-
-test('ReadUInt8 on an empty buffer returns 0', function() {
-    var r = new BinaryReader([], 'big');
-    assert.equal(r.Length, 0);
-    assert.equal(r.ReadUInt8(), 0);
-    assert.equal(r.ReadInt8(), 0);
-});
-
-test('ReadBytes returns an empty Buffer when count exceeds remaining', function() {
-    var r = new BinaryReader([1, 2, 3], 'big');
-    var out = r.ReadBytes(5);
-    assert.ok(Buffer.isBuffer(out));
-    assert.equal(out.length, 0);
-    assert.equal(r.Position, 0, 'over-long ReadBytes does not advance');
-    assert.equal(r.ByteBuffer.length, 3);
-});
-
-test('ReadBytes reading exactly the remaining length succeeds', function() {
-    var r = new BinaryReader([1, 2, 3], 'big');
-    assert.deepEqual(Array.from(r.ReadBytes(3)), [1, 2, 3]);
-    assert.equal(r.Position, 3);
-    assert.equal(r.ByteBuffer.length, 0);
-});

package/test/reader.test.js

@@ -1,106 +0,0 @@
-var test = require('node:test');
-var assert = require('node:assert/strict');
-var binutils = require('../binutils.js');
-var BinaryReader = binutils.BinaryReader;
-
-function reader(arr, endian) {
-    return new BinaryReader(Buffer.from(arr), endian);
-}
-
-test('BinaryReader: constructor defaults', function() {
-    var r = reader([1, 2, 3]);
-    assert.equal(r.Endianness, 'big', 'defaults to big-endian');
-    assert.equal(r.Encoding, 'ascii', 'defaults to ascii encoding');
-    assert.equal(r.Length, 3, 'Length is the original buffer length');
-    assert.equal(r.Position, 0, 'Position starts at 0');
-    assert.equal(r.ByteBuffer.length, 3);
-});
-
-test('BinaryReader: ReadUInt8', function() {
-    var r = reader([200, 5]);
-    assert.equal(r.ReadUInt8(), 200);
-    assert.equal(r.ReadUInt8(), 5);
-});
-
-test('BinaryReader: ReadInt8 (signed)', function() {
-    var r = reader([0xFF, 0x80, 0x7F]);
-    assert.equal(r.ReadInt8(), -1);
-    assert.equal(r.ReadInt8(), -128);
-    assert.equal(r.ReadInt8(), 127);
-});
-
-test('BinaryReader: ReadUInt16 honors endianness', function() {
-    assert.equal(reader([0x12, 0x34], 'big').ReadUInt16(), 0x1234);
-    assert.equal(reader([0x12, 0x34], 'little').ReadUInt16(), 0x3412);
-});
-
-test('BinaryReader: ReadInt16 (signed)', function() {
-    assert.equal(reader([0xFF, 0xFF], 'big').ReadInt16(), -1);
-    assert.equal(reader([0x80, 0x00], 'big').ReadInt16(), -32768);
-    assert.equal(reader([0x00, 0x80], 'little').ReadInt16(), -32768);
-});
-
-test('BinaryReader: ReadUInt32 honors endianness', function() {
-    assert.equal(reader([0x12, 0x34, 0x56, 0x78], 'big').ReadUInt32(), 0x12345678);
-    assert.equal(reader([0x78, 0x56, 0x34, 0x12], 'little').ReadUInt32(), 0x12345678);
-});
-
-test('BinaryReader: ReadInt32 (signed)', function() {
-    assert.equal(reader([0xFF, 0xFF, 0xFF, 0xFF], 'big').ReadInt32(), -1);
-    assert.equal(reader([0x80, 0x00, 0x00, 0x00], 'big').ReadInt32(), -2147483648);
-});
-
-test('BinaryReader: ReadUInt64 returns a BigInt', function() {
-    var r = reader([0, 0, 0, 0, 0, 0, 0, 5], 'big');
-    var v = r.ReadUInt64();
-    assert.equal(typeof v, 'bigint');
-    assert.equal(v, 5n);
-    assert.equal(reader([5, 0, 0, 0, 0, 0, 0, 0], 'little').ReadUInt64(), 5n);
-});
-
-test('BinaryReader: ReadInt64 returns a signed BigInt', function() {
-    assert.equal(reader([0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF], 'big').ReadInt64(), -1n);
-});
-
-test('BinaryReader: ReadFloat', function() {
-    // 1.5 as IEEE-754 single precision = 0x3FC00000
-    assert.equal(reader([0x3F, 0xC0, 0x00, 0x00], 'big').ReadFloat(), 1.5);
-    assert.equal(reader([0x00, 0x00, 0xC0, 0x3F], 'little').ReadFloat(), 1.5);
-});
-
-test('BinaryReader: ReadDouble', function() {
-    // 1.5 as IEEE-754 double precision = 0x3FF8000000000000
-    assert.equal(reader([0x3F, 0xF8, 0, 0, 0, 0, 0, 0], 'big').ReadDouble(), 1.5);
-});
-
-test('BinaryReader: ReadBytes returns a Buffer of the requested length', function() {
-    var r = reader([1, 2, 3, 4, 5, 6]);
-    var out = r.ReadBytes(4);
-    assert.ok(Buffer.isBuffer(out));
-    assert.deepEqual(Array.from(out), [1, 2, 3, 4]);
-    assert.equal(r.Position, 4);
-    assert.equal(r.ByteBuffer.length, 2);
-});
-
-test('BinaryReader: Position advances and Length stays constant; ByteBuffer shrinks', function() {
-    var r = reader([1, 2, 3, 4, 5, 6, 7, 8], 'big');
-
-    assert.equal(r.ReadUInt8(), 1);
-    assert.equal(r.Position, 1);
-    assert.equal(r.Length, 8, 'Length never changes on reads');
-    assert.equal(r.ByteBuffer.length, 7, 'ByteBuffer shrinks by consumed bytes');
-
-    assert.equal(r.ReadUInt16(), 0x0203);
-    assert.equal(r.Position, 3);
-    assert.equal(r.ByteBuffer.length, 5);
-
-    assert.equal(r.ReadUInt32(), 0x04050607);
-    assert.equal(r.Position, 7);
-    assert.equal(r.ByteBuffer.length, 1);
-});
-
-test('BinaryReader: same bytes decode differently per endianness', function() {
-    var b = [0x00, 0x00, 0x00, 0x01];
-    assert.equal(reader(b, 'big').ReadUInt32(), 1);
-    assert.equal(reader(b, 'little').ReadUInt32(), 0x01000000);
-});

package/test/readme-examples.test.js

@@ -1,33 +0,0 @@
-var test = require('node:test');
-var assert = require('node:assert/strict');
-var binutils = require('../binutils.js');
-
-// These mirror the worked examples in README.md. If the documented output ever
-// changes, the docs and these tests must change together.
-
-test('README reader example', function() {
-    var buffer = Buffer.from([1, 0, 2, 0, 0, 0, 3, 1, 2, 3, 4, 5, 6]);
-    var reader = new binutils.BinaryReader(buffer);
-
-    assert.equal(reader.ReadUInt8(), 1);
-    assert.equal(reader.ReadUInt16(), 2);
-    assert.equal(reader.ReadUInt32(), 3);
-    assert.deepEqual(Array.from(reader.ReadBytes(6)), [1, 2, 3, 4, 5, 6]);
-    assert.equal(reader.Position, 13);
-    assert.equal(reader.Length, 13);
-});
-
-test('README writer example', function() {
-    var writer = new binutils.BinaryWriter();
-
-    writer.WriteUInt16(65535);
-    writer.WriteUInt32(0);
-    writer.WriteInt32(-1);
-    writer.WriteBytes([5, 4, 3, 2, 1]);
-
-    assert.deepEqual(
-        Array.from(writer.ByteBuffer),
-        [0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 5, 4, 3, 2, 1]
-    );
-    assert.equal(writer.Length, 15);
-});

package/test/roundtrip.test.js

@@ -1,120 +0,0 @@
-var test = require('node:test');
-var assert = require('node:assert/strict');
-var binutils = require('../binutils.js');
-var BinaryReader = binutils.BinaryReader;
-var BinaryWriter = binutils.BinaryWriter;
-
-// Write a value with WriteMethod, then read it back with ReadMethod, asserting
-// equality across both endiannesses.
-function roundTrip(writeMethod, readMethod, value, compare) {
-    ['big', 'little'].forEach(function(endian) {
-        var w = new BinaryWriter(endian);
-        w[writeMethod](value);
-        var r = new BinaryReader(w.ByteBuffer, endian);
-        var got = r[readMethod]();
-        if (compare) {
-            compare(got, value, endian);
-        } else {
-            assert.equal(got, value, writeMethod + '/' + readMethod + ' (' + endian + ')');
-        }
-    });
-}
-
-test('round-trip: UInt8', function() {
-    roundTrip('WriteUInt8', 'ReadUInt8', 0);
-    roundTrip('WriteUInt8', 'ReadUInt8', 200);
-    roundTrip('WriteUInt8', 'ReadUInt8', 255);
-});
-
-test('round-trip: Int8', function() {
-    roundTrip('WriteInt8', 'ReadInt8', -128);
-    roundTrip('WriteInt8', 'ReadInt8', -1);
-    roundTrip('WriteInt8', 'ReadInt8', 127);
-});
-
-test('round-trip: UInt16', function() {
-    roundTrip('WriteUInt16', 'ReadUInt16', 0);
-    roundTrip('WriteUInt16', 'ReadUInt16', 0xBEEF);
-    roundTrip('WriteUInt16', 'ReadUInt16', 0xFFFF);
-});
-
-test('round-trip: Int16', function() {
-    roundTrip('WriteInt16', 'ReadInt16', -32768);
-    roundTrip('WriteInt16', 'ReadInt16', -1);
-    roundTrip('WriteInt16', 'ReadInt16', 32767);
-});
-
-test('round-trip: UInt32', function() {
-    roundTrip('WriteUInt32', 'ReadUInt32', 0);
-    roundTrip('WriteUInt32', 'ReadUInt32', 0xDEADBEEF);
-    roundTrip('WriteUInt32', 'ReadUInt32', 0xFFFFFFFF);
-});
-
-test('round-trip: Int32', function() {
-    roundTrip('WriteInt32', 'ReadInt32', -2147483648);
-    roundTrip('WriteInt32', 'ReadInt32', -1);
-    roundTrip('WriteInt32', 'ReadInt32', 2147483647);
-});
-
-test('round-trip: Float (within single-precision tolerance)', function() {
-    roundTrip('WriteFloat', 'ReadFloat', 1.5);
-    roundTrip('WriteFloat', 'ReadFloat', 3.14, function(got, want, endian) {
-        assert.ok(Math.abs(got - want) < 1e-5, 'Float ~3.14 (' + endian + '), got ' + got);
-    });
-});
-
-test('round-trip: Double (exact)', function() {
-    roundTrip('WriteDouble', 'ReadDouble', Math.PI);
-    roundTrip('WriteDouble', 'ReadDouble', -123456.789);
-});
-
-test('round-trip: Bytes', function() {
-    ['big', 'little'].forEach(function(endian) {
-        var payload = [1, 2, 3, 4, 5];
-        var w = new BinaryWriter(endian);
-        w.WriteBytes(payload);
-        var r = new BinaryReader(w.ByteBuffer, endian);
-        assert.deepEqual(Array.from(r.ReadBytes(payload.length)), payload);
-    });
-});
-
-// 64-bit round-trips. The writers accept a Number or a BigInt and emit all 8
-// bytes; the reader always returns a BigInt.
-
-test('round-trip: UInt64 (BigInt argument)', function() {
-    var value = 0x1234567890ABCDEFn;
-    ['big', 'little'].forEach(function(endian) {
-        var w = new BinaryWriter(endian);
-        w.WriteUInt64(value);
-        var r = new BinaryReader(w.ByteBuffer, endian);
-        assert.equal(r.ReadUInt64(), value);
-    });
-});
-
-test('round-trip: UInt64 (Number argument is coerced)', function() {
-    ['big', 'little'].forEach(function(endian) {
-        var w = new BinaryWriter(endian);
-        w.WriteUInt64(123);
-        var r = new BinaryReader(w.ByteBuffer, endian);
-        assert.equal(r.ReadUInt64(), 123n);
-    });
-});
-
-test('round-trip: Int64 (BigInt argument)', function() {
-    var value = -81985529216486896n;
-    ['big', 'little'].forEach(function(endian) {
-        var w = new BinaryWriter(endian);
-        w.WriteInt64(value);
-        var r = new BinaryReader(w.ByteBuffer, endian);
-        assert.equal(r.ReadInt64(), value);
-    });
-});
-
-test('round-trip: Int64 (negative Number argument is coerced)', function() {
-    ['big', 'little'].forEach(function(endian) {
-        var w = new BinaryWriter(endian);
-        w.WriteInt64(-123);
-        var r = new BinaryReader(w.ByteBuffer, endian);
-        assert.equal(r.ReadInt64(), -123n);
-    });
-});