binutils64 0.1.4 → 0.2.0

package/CHANGELOG.md

@@ -0,0 +1,56 @@
+# Changelog
+
+All notable changes to this project are documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [0.2.0] - 2026-07-02
+
+### Added
+
+- MIT license (`LICENSE` file and `license` field in `package.json`).
+- Bundled TypeScript type definitions (`binutils.d.ts`).
+- `CHANGELOG.md` (this file).
+- ESLint configuration that locks `binutils.js` to ES5 syntax, an `npm run lint`
+  script, and a CI lint job.
+- GitHub Actions publish workflow that releases to npm with provenance.
+- Package metadata: `files` whitelist, `exports` map, `keywords`, `bugs`, `homepage`.
+- `.editorconfig`.
+
+### Changed
+
+- Raised the declared Node.js floor (`engines.node`) from `>=0.12` to `>=12`,
+  matching the actual requirement of the 64-bit `BigInt` methods.
+- Replaced the deprecated `new Buffer(...)` constructor with
+  `Buffer.alloc()`/`Buffer.from()`; the `DEP0005` deprecation warning is gone.
+  No behavior change.
+- `repository.url` now uses `git+https://` instead of the retired `git://` protocol.
+
+## [0.1.4] - 2026-05-28
+
+### Added
+
+- Test suite using the built-in `node:test` runner: reader, writer, round-trip,
+  edge-case and README-example coverage.
+- GitHub Actions CI running the tests on Node.js 20, 22 and 24.
+
+## [0.1.3] - 2024-11-01
+
+### Fixed
+
+- `ReadInt64` returning incorrect values.
+
+## [0.1.2] - 2018-06-15
+
+### Changed
+
+- README updates.
+
+## [0.1.1] - 2018-06-15
+
+### Added
+
+- First release of `binutils64`: `BinaryReader` and `BinaryWriter` with selectable
+  endianness, signed/unsigned 8/16/32-bit integers, floats, doubles, raw byte runs,
+  and 64-bit integers via `BigInt`.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2013-2026 Mihail Shumilov
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -3,7 +3,12 @@
 > A .NET-style `BinaryReader` and `BinaryWriter` for Node.js, with selectable endianness.
 
 [![npm version](https://img.shields.io/npm/v/binutils64.svg)](https://www.npmjs.com/package/binutils64)
+[![npm downloads](https://img.shields.io/npm/dm/binutils64.svg)](https://www.npmjs.com/package/binutils64)
 [![Tests](https://github.com/mihailShumilov/node-binutils/actions/workflows/test.yml/badge.svg)](https://github.com/mihailShumilov/node-binutils/actions/workflows/test.yml)
+[![node version](https://img.shields.io/node/v/binutils64.svg)](https://www.npmjs.com/package/binutils64)
+[![license](https://img.shields.io/github/license/mihailShumilov/node-binutils.svg)](https://github.com/mihailShumilov/node-binutils/blob/master/LICENSE)
+[![types](https://img.shields.io/npm/types/binutils64.svg)](https://www.npmjs.com/package/binutils64)
+[![install size](https://packagephobia.com/badge?p=binutils64)](https://packagephobia.com/result?p=binutils64)
 
 `binutils64` provides two small classes — `BinaryReader` and `BinaryWriter` — that
 make it easy to parse and produce binary data sequentially, with an API modelled on
@@ -24,6 +29,7 @@ doubles, and raw byte runs.
 - [Requirements and compatibility](#requirements-and-compatibility)
 - [Testing](#testing)
 - [Contributing](#contributing)
+- [License](#license)
 
 ## Features
 
@@ -32,6 +38,7 @@ doubles, and raw byte runs.
 - 64-bit integers via JavaScript `BigInt`.
 - Signed and unsigned integers, IEEE-754 `float` and `double`, and raw byte runs.
 - Zero runtime dependencies.
+- Bundled TypeScript type definitions.
 
 ## Installation
 
@@ -232,11 +239,11 @@ console.log(record, 'read', reader.Position, 'of', reader.Length, 'bytes');
 
 ## Requirements and compatibility
 
-- **Node.js.** The 8-, 16- and 32-bit methods run on very old Node.js versions, but
-  the 64-bit methods (`ReadUInt64`, `ReadInt64`, `WriteUInt64`, `WriteInt64`) rely on
-  `BigInt` and the `Buffer` big-integer methods, which require **Node.js 12 or newer**.
-- The library uses the legacy `Buffer` constructor internally; on modern Node.js you
-  may see a one-time `DEP0005` deprecation warning. This does not affect behavior.
+- **Node.js 12 or newer** (declared in `package.json` `engines`). The 64-bit methods
+  (`ReadUInt64`, `ReadInt64`, `WriteUInt64`, `WriteInt64`) rely on `BigInt` and the
+  `Buffer` big-integer methods introduced in Node.js 12.
+- **TypeScript typings are bundled** (`binutils.d.ts`) — no separate `@types`
+  package is needed.
 - Running the test suite uses the built-in `node:test` runner, which requires
   **Node.js 18 or newer**.
 
@@ -253,4 +260,10 @@ the documented examples. Continuous integration runs it on Node.js 20, 22 and 24
 ## Contributing
 
 Issues and pull requests are welcome. Please add or update tests for any behavioral
-change and make sure `npm test` passes before opening a pull request.
+change, note it in `CHANGELOG.md` under *Unreleased*, and make sure `npm test` and
+`npm run lint` pass before opening a pull request (run `npm ci` once to install the
+linter).
+
+## License
+
+[MIT](LICENSE)

package/binutils.d.ts

@@ -0,0 +1,83 @@
+/// <reference types="node" />
+
+export = binutils;
+
+declare namespace binutils {
+    type Endianness = 'big' | 'little';
+
+    class BinaryReader {
+        /**
+         * Wraps a copy of the input data and consumes it from the front as you read.
+         * A `Buffer` input is copied, so the source is never mutated.
+         * Throws if `input` is not a `Buffer`, array, or string.
+         */
+        constructor(
+            input: Buffer | ReadonlyArray<number> | string,
+            endianness?: Endianness,
+            encoding?: BufferEncoding
+        );
+
+        /** The remaining unread bytes. Shrinks as `Read*` methods consume it. */
+        ByteBuffer: Buffer;
+        /** Byte order used by all multi-byte reads. */
+        Endianness: Endianness;
+        /** Encoding used to turn a string input into bytes. */
+        Encoding: BufferEncoding;
+        /** Length of the original input in bytes. Never changes as you read. */
+        Length: number;
+        /** Number of bytes consumed so far. */
+        Position: number;
+
+        /** Reads 1 byte. Returns 0 (without advancing) if no bytes remain. */
+        ReadUInt8(): number;
+        /** Reads 2 bytes. Returns 0 (without advancing) if fewer than 2 bytes remain. */
+        ReadUInt16(): number;
+        /** Reads 4 bytes. Returns 0 (without advancing) if fewer than 4 bytes remain. */
+        ReadUInt32(): number;
+        /** Reads 8 bytes as an unsigned BigInt. Returns the number 0 (without advancing) if fewer than 8 bytes remain. */
+        ReadUInt64(): bigint | 0;
+        /** Reads 1 byte, signed. Returns 0 (without advancing) if no bytes remain. */
+        ReadInt8(): number;
+        /** Reads 2 bytes, signed. Returns 0 (without advancing) if fewer than 2 bytes remain. */
+        ReadInt16(): number;
+        /** Reads 4 bytes, signed. Returns 0 (without advancing) if fewer than 4 bytes remain. */
+        ReadInt32(): number;
+        /** Reads 8 bytes as a signed BigInt. Returns the number 0 (without advancing) if fewer than 8 bytes remain. */
+        ReadInt64(): bigint | 0;
+        /** Reads 4 bytes as an IEEE-754 single. Returns 0 (without advancing) if fewer than 4 bytes remain. */
+        ReadFloat(): number;
+        /** Reads 8 bytes as an IEEE-754 double. Returns 0 (without advancing) if fewer than 8 bytes remain. */
+        ReadDouble(): number;
+        /** Copies `count` bytes into a new Buffer. Returns an empty Buffer (without advancing) if fewer than `count` bytes remain. */
+        ReadBytes(count: number): Buffer;
+    }
+
+    class BinaryWriter {
+        /** Accumulates bytes in an internal buffer that grows with every write. */
+        constructor(endianness?: Endianness, encoding?: BufferEncoding);
+
+        /** All bytes written so far. */
+        ByteBuffer: Buffer;
+        /** Byte order used by all multi-byte writes. */
+        Endianness: Endianness;
+        /** Stored on the instance; reserved. */
+        Encoding: BufferEncoding;
+        /** The current length of `ByteBuffer`. */
+        Length: number;
+
+        WriteUInt8(value: number): void;
+        WriteUInt16(value: number): void;
+        WriteUInt32(value: number): void;
+        /** Accepts a number or BigInt; the value is coerced with `BigInt(value)`. */
+        WriteUInt64(value: number | bigint): void;
+        WriteInt8(value: number): void;
+        WriteInt16(value: number): void;
+        WriteInt32(value: number): void;
+        /** Accepts a number or BigInt; the value is coerced with `BigInt(value)`. */
+        WriteInt64(value: number | bigint): void;
+        WriteFloat(value: number): void;
+        WriteDouble(value: number): void;
+        /** Strings are written as one byte per character code. Throws on any other input type. */
+        WriteBytes(value: Buffer | ReadonlyArray<number> | string): void;
+    }
+}

package/binutils.js

@@ -1,9 +1,9 @@
 var BinaryReader = function(p_InputBuffer, p_Endianness, p_Encoding) {
     // Instantiate the buffer (if needed)
     if (p_InputBuffer instanceof Buffer) {
-        this.ByteBuffer = new Buffer(p_InputBuffer);
+        this.ByteBuffer = Buffer.from(p_InputBuffer);
     } else if (p_InputBuffer instanceof Array || typeof p_InputBuffer == 'string') {
-        this.ByteBuffer = new Buffer(p_InputBuffer, p_Encoding);
+        this.ByteBuffer = Buffer.from(p_InputBuffer, p_Encoding);
     } else {
         throw new Error('Invalid buffer input for BinaryReader (' + typeof p_InputBuffer + ')');
     }
@@ -134,10 +134,10 @@ BinaryReader.prototype = {
 
     ReadBytes: function(p_Count) {
         if (p_Count > this.ByteBuffer.length) {
-            return new Buffer(0);
+            return Buffer.alloc(0);
         }
 
-        var s_Val = new Buffer(p_Count);
+        var s_Val = Buffer.alloc(p_Count);
         this.ByteBuffer.copy(s_Val, 0, 0, p_Count);
 
         this.ByteBuffer = this.ByteBuffer.slice(p_Count);
@@ -151,7 +151,7 @@ BinaryReader.prototype = {
 
 var BinaryWriter = function(p_Endianness, p_Encoding) {
     // Instantiate the buffer
-    this.ByteBuffer = new Buffer(0);
+    this.ByteBuffer = Buffer.alloc(0);
 
     // Set the endianness
     this.Endianness = p_Endianness || 'big';
@@ -165,14 +165,14 @@ var BinaryWriter = function(p_Endianness, p_Encoding) {
 
 BinaryWriter.prototype = {
     WriteUInt8: function(p_Value) {
-        var s_TempBuffer = new Buffer(1);
+        var s_TempBuffer = Buffer.alloc(1);
         s_TempBuffer.writeUInt8(p_Value, 0);
         this.Length += 1;
         this.ByteBuffer = Buffer.concat([this.ByteBuffer, s_TempBuffer], this.Length);
     },
 
     WriteUInt16: function(p_Value) {
-        var s_TempBuffer = new Buffer(2);
+        var s_TempBuffer = Buffer.alloc(2);
         if (this.Endianness == 'little') {
             s_TempBuffer.writeUInt16LE(p_Value, 0);
         } else {
@@ -183,7 +183,7 @@ BinaryWriter.prototype = {
     },
 
     WriteUInt32: function(p_Value) {
-        var s_TempBuffer = new Buffer(4);
+        var s_TempBuffer = Buffer.alloc(4);
         if (this.Endianness == 'little') {
             s_TempBuffer.writeUInt32LE(p_Value, 0);
         } else {
@@ -194,7 +194,7 @@ BinaryWriter.prototype = {
     },
 
     WriteUInt64: function(p_Value) {
-        var s_TempBuffer = new Buffer(8);
+        var s_TempBuffer = Buffer.alloc(8);
         var s_Value = BigInt(p_Value);
         if (this.Endianness == 'little') {
             s_TempBuffer.writeBigUInt64LE(s_Value, 0);
@@ -206,14 +206,14 @@ BinaryWriter.prototype = {
     },
 
     WriteInt8: function(p_Value) {
-        var s_TempBuffer = new Buffer(1);
+        var s_TempBuffer = Buffer.alloc(1);
         s_TempBuffer.writeInt8(p_Value, 0);
         this.Length += 1;
         this.ByteBuffer = Buffer.concat([this.ByteBuffer, s_TempBuffer], this.Length);
     },
 
     WriteInt16: function(p_Value) {
-        var s_TempBuffer = new Buffer(2);
+        var s_TempBuffer = Buffer.alloc(2);
         if (this.Endianness == 'little') {
             s_TempBuffer.writeInt16LE(p_Value, 0);
         } else {
@@ -224,7 +224,7 @@ BinaryWriter.prototype = {
     },
 
     WriteInt32: function(p_Value) {
-        var s_TempBuffer = new Buffer(4);
+        var s_TempBuffer = Buffer.alloc(4);
         if (this.Endianness == 'little') {
             s_TempBuffer.writeInt32LE(p_Value, 0);
         } else {
@@ -235,7 +235,7 @@ BinaryWriter.prototype = {
     },
 
     WriteInt64: function(p_Value) {
-        var s_TempBuffer = new Buffer(8);
+        var s_TempBuffer = Buffer.alloc(8);
         var s_Value = BigInt(p_Value);
         if (this.Endianness == 'little') {
             s_TempBuffer.writeBigInt64LE(s_Value, 0);
@@ -247,7 +247,7 @@ BinaryWriter.prototype = {
     },
 
     WriteFloat: function(p_Value) {
-        var s_TempBuffer = new Buffer(4);
+        var s_TempBuffer = Buffer.alloc(4);
         if (this.Endianness == 'little') {
             s_TempBuffer.writeFloatLE(p_Value, 0);
         } else {
@@ -258,7 +258,7 @@ BinaryWriter.prototype = {
     },
 
     WriteDouble: function(p_Value) {
-        var s_TempBuffer = new Buffer(8);
+        var s_TempBuffer = Buffer.alloc(8);
         if (this.Endianness == 'little') {
             s_TempBuffer.writeDoubleLE(p_Value, 0);
         } else {
@@ -285,7 +285,7 @@ BinaryWriter.prototype = {
             throw new Error("Invalid Buffer object provided.");
         }
 
-        var s_TempBuffer = (p_Value instanceof Buffer) ? p_Value : new Buffer(p_Value);
+        var s_TempBuffer = (p_Value instanceof Buffer) ? p_Value : Buffer.from(p_Value);
 
         this.Length += s_TempBuffer.length;
         this.ByteBuffer = Buffer.concat([this.ByteBuffer, s_TempBuffer], this.Length);

package/package.json

@@ -1,17 +1,54 @@
-{
-    "name": "binutils64",
-    "version": "0.1.4",
-    "author": "Mihail Shumilov <mschumilow@gmail.com>",
-    "description": "A .NET-like BinaryReader and BinaryWriter with endianness support.",
-    "main": "./binutils.js",
-    "scripts": {
-        "test": "node --test"
-    },
-    "engines": {
-        "node": ">=0.12"
-    },
-    "repository": {
-        "type" : "git",
-        "url" : "git://github.com/mihailShumilov/node-binutils.git"
-    }
-}
+{
+    "name": "binutils64",
+    "version": "0.2.0",
+    "author": "Mihail Shumilov <mschumilow@gmail.com>",
+    "description": "A .NET-like BinaryReader and BinaryWriter with endianness support.",
+    "license": "MIT",
+    "keywords": [
+        "binary",
+        "buffer",
+        "binaryreader",
+        "binarywriter",
+        "reader",
+        "writer",
+        "endianness",
+        "endian",
+        "bigint",
+        "int64",
+        "uint64",
+        "parse",
+        "serialize"
+    ],
+    "main": "./binutils.js",
+    "types": "./binutils.d.ts",
+    "exports": {
+        ".": {
+            "types": "./binutils.d.ts",
+            "default": "./binutils.js"
+        }
+    },
+    "files": [
+        "binutils.js",
+        "binutils.d.ts",
+        "CHANGELOG.md"
+    ],
+    "scripts": {
+        "test": "node --test",
+        "lint": "eslint ."
+    },
+    "engines": {
+        "node": ">=12"
+    },
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/mihailShumilov/node-binutils.git"
+    },
+    "bugs": {
+        "url": "https://github.com/mihailShumilov/node-binutils/issues"
+    },
+    "homepage": "https://github.com/mihailShumilov/node-binutils#readme",
+    "devDependencies": {
+        "@eslint/js": "^10.0.1",
+        "eslint": "^10.6.0"
+    }
+}

package/.claude/agents/binutils-reviewer.md

@@ -1,58 +0,0 @@
----
-name: binutils-reviewer
-description: Reviews changes to the binutils64 library (binutils.js, README.md, tests) for binary-correctness bugs and convention adherence. Use proactively after any edit to binutils.js or when asked to review a Read/Write change, a new type, or a PR touching this library.
-tools: Read, Grep, Glob, Bash
-model: sonnet
----
-
-You are a focused code reviewer for **binutils64**, a single-file ES5 CommonJS
-library (`binutils.js`) providing .NET-style `BinaryReader` and `BinaryWriter`
-with selectable endianness. Your job is to catch binary-correctness bugs and
-convention drift in changes to this library. Be precise and skeptical — this code
-already shipped a real width-mismatch bug (the 64-bit writers emit only 32 bits).
-
-## What to review
-
-Read `binutils.js`, the relevant `README.md` sections, and any `test/` files. Use
-`git diff` (via Bash) to scope the change when reviewing edits. If a round-trip is
-in doubt, actually run it: `node -e "..."` or `node --test`.
-
-## Correctness checklist (highest priority)
-
-1. **Write width == read width.** For every `WriteX`/`ReadX` pair, the number of
-   bytes written must equal the bytes read and the declared width `N`. Flag any
-   writer using a narrower method than its buffer size (e.g. `writeUInt32LE` into
-   an 8-byte buffer — this was the original `WriteUInt64`/`WriteInt64` bug, since
-   fixed). 64-bit writers use `writeBigUInt64*`/`writeBigInt64*` and coerce with
-   `BigInt(p_Value)`. Prefer confirming with a real round-trip.
-2. **Endianness branches** present and correct for every multi-byte method: the
-   `'little'` branch uses the `*LE` variant, the else branch uses `*BE`. Single-byte
-   methods (`*UInt8`/`*Int8`) must NOT have an endianness branch.
-3. **Reader is destructive and consistent**: each `ReadX` slices exactly `N` bytes
-   off `this.ByteBuffer` and advances `this.Position` by exactly `N`. `this.Length`
-   must NOT change on reads (it reflects the original buffer length).
-4. **Writer accounting**: each `WriteX` increases `this.Length` by exactly `N` and
-   passes the updated `this.Length` as the `Buffer.concat` total-length argument.
-5. **Out-of-range reads return the zero value** (`0`, `0.0`, or empty `Buffer`) and
-   never throw. Verify the length guard matches the width.
-6. **Signed/unsigned and BigInt**: signed types use the signed Buffer methods;
-   64-bit reads return `bigint` (`readBig*64*`). Watch for sign/precision errors.
-
-## Convention checklist
-
-- ES5 only: `var`, prototype assignment. No `let`/`const`/classes/arrow functions.
-- `PascalCase` method and property names; parameters prefixed `p_`; locals `s_`.
-- `new Buffer(...)` is intentional for `node >=0.12`. Do NOT recommend
-  `Buffer.alloc`/`Buffer.from` unless the change also raises `engines.node`.
-- New/changed public methods must have matching `README.md` entries with the
-  existing phrasing, and a round-trip test.
-- Methods placed beside their family in the file, ordered consistently.
-
-## Output format
-
-Report findings grouped by severity. For each: a one-line title, the
-`binutils.js:line` reference, why it is wrong, and the concrete fix. Lead with
-**Correctness** issues, then **Conventions**, then **Docs/Tests**. State a
-confidence level and only raise convention nits if no correctness issue is
-outstanding. If you ran a round-trip to confirm, show the command and result. If
-nothing is wrong, say so plainly — do not invent issues.

package/.claude/settings.local.json

@@ -1,21 +0,0 @@
-{
-  "permissions": {
-    "allow": [
-      "Bash(git checkout *)",
-      "Bash(node *)",
-      "Bash(echo \"exit code: $?\")",
-      "Read(//tmp/**)",
-      "Bash(echo \"exit: $?\")",
-      "mcp__claude_ai_Context7__resolve-library-id",
-      "mcp__claude_ai_Context7__query-docs",
-      "Bash(python3 -c \"import yaml,sys; yaml.safe_load\\(open\\('.github/workflows/test.yml'\\)\\); print\\('YAML OK'\\)\")",
-      "Bash(git add *)",
-      "Bash(git commit -m 'fix 64-bit writers and WriteBytes type guard *)",
-      "Bash(git commit -m 'add test suite using node:test *)",
-      "Bash(git commit -m 'add github actions workflow to run tests *)",
-      "Bash(git commit -m 'add project docs and claude tooling *)",
-      "Bash(git push *)",
-      "Bash(git commit -m 'rewrite readme with full api reference and examples *)"
-    ]
-  }
-}

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);
-    });
-});

package/test/writer.test.js

@@ -1,115 +0,0 @@
-var test = require('node:test');
-var assert = require('node:assert/strict');
-var binutils = require('../binutils.js');
-var BinaryWriter = binutils.BinaryWriter;
-
-function bytes(writer) {
-    return Array.from(writer.ByteBuffer);
-}
-
-test('BinaryWriter: constructor defaults', function() {
-    var w = new BinaryWriter();
-    assert.equal(w.Endianness, 'big');
-    assert.equal(w.Encoding, 'ascii');
-    assert.equal(w.Length, 0);
-    assert.equal(w.ByteBuffer.length, 0);
-});
-
-test('BinaryWriter: WriteUInt8', function() {
-    var w = new BinaryWriter();
-    w.WriteUInt8(200);
-    assert.deepEqual(bytes(w), [200]);
-    assert.equal(w.Length, 1);
-});
-
-test('BinaryWriter: WriteInt8 (signed)', function() {
-    var w = new BinaryWriter();
-    w.WriteInt8(-1);
-    assert.deepEqual(bytes(w), [0xFF]);
-    assert.equal(w.Length, 1);
-});
-
-test('BinaryWriter: WriteUInt16 honors endianness', function() {
-    var big = new BinaryWriter('big');
-    big.WriteUInt16(0x1234);
-    assert.deepEqual(bytes(big), [0x12, 0x34]);
-    assert.equal(big.Length, 2);
-
-    var little = new BinaryWriter('little');
-    little.WriteUInt16(0x1234);
-    assert.deepEqual(bytes(little), [0x34, 0x12]);
-});
-
-test('BinaryWriter: WriteUInt32 honors endianness', function() {
-    var big = new BinaryWriter('big');
-    big.WriteUInt32(0x12345678);
-    assert.deepEqual(bytes(big), [0x12, 0x34, 0x56, 0x78]);
-    assert.equal(big.Length, 4);
-
-    var little = new BinaryWriter('little');
-    little.WriteUInt32(0x12345678);
-    assert.deepEqual(bytes(little), [0x78, 0x56, 0x34, 0x12]);
-});
-
-test('BinaryWriter: WriteInt16 / WriteInt32 (signed)', function() {
-    var w16 = new BinaryWriter('big');
-    w16.WriteInt16(-2);
-    assert.deepEqual(bytes(w16), [0xFF, 0xFE]);
-
-    var w32 = new BinaryWriter('little');
-    w32.WriteInt32(-1);
-    assert.deepEqual(bytes(w32), [0xFF, 0xFF, 0xFF, 0xFF]);
-});
-
-test('BinaryWriter: WriteFloat', function() {
-    var big = new BinaryWriter('big');
-    big.WriteFloat(1.5);
-    assert.deepEqual(bytes(big), [0x3F, 0xC0, 0x00, 0x00]);
-    assert.equal(big.Length, 4);
-
-    var little = new BinaryWriter('little');
-    little.WriteFloat(1.5);
-    assert.deepEqual(bytes(little), [0x00, 0x00, 0xC0, 0x3F]);
-});
-
-test('BinaryWriter: WriteDouble', function() {
-    var w = new BinaryWriter('big');
-    w.WriteDouble(1.5);
-    assert.deepEqual(bytes(w), [0x3F, 0xF8, 0, 0, 0, 0, 0, 0]);
-    assert.equal(w.Length, 8);
-});
-
-test('BinaryWriter: WriteBytes accepts an array', function() {
-    var w = new BinaryWriter();
-    w.WriteBytes([1, 2, 3]);
-    assert.deepEqual(bytes(w), [1, 2, 3]);
-    assert.equal(w.Length, 3);
-});
-
-test('BinaryWriter: WriteBytes accepts a Buffer', function() {
-    var w = new BinaryWriter();
-    w.WriteBytes(Buffer.from([9, 8, 7]));
-    assert.deepEqual(bytes(w), [9, 8, 7]);
-    assert.equal(w.Length, 3);
-});
-
-test('BinaryWriter: WriteBytes accepts a string (per-char codes)', function() {
-    var w = new BinaryWriter();
-    w.WriteBytes('ABC');
-    assert.deepEqual(bytes(w), [65, 66, 67]);
-    assert.equal(w.Length, 3);
-});
-
-test('BinaryWriter: WriteBytes rejects non-Buffer/non-Array input', function() {
-    assert.throws(function() { new BinaryWriter().WriteBytes(4); }, /Invalid Buffer object/);
-    assert.throws(function() { new BinaryWriter().WriteBytes({}); }, /Invalid Buffer object/);
-});
-
-test('BinaryWriter: multiple writes accumulate and track Length', function() {
-    var w = new BinaryWriter('big');
-    w.WriteUInt8(1);
-    w.WriteUInt16(0x0203);
-    w.WriteUInt32(0x04050607);
-    assert.deepEqual(bytes(w), [1, 2, 3, 4, 5, 6, 7]);
-    assert.equal(w.Length, 7);
-});