binutils64 0.1.4 → 0.3.0

package/CHANGELOG.md

@@ -0,0 +1,65 @@
+# 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.3.0] - 2026-07-04
+
+### Added
+
+- `BinaryReader.ReadString(count)` and `BinaryWriter.WriteString(value)`: read and
+  write strings using the instance's `Encoding` (`'ascii'` by default). Reading
+  past the end returns an empty string without advancing; writing a non-string
+  throws.
+
+## [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,13 +3,18 @@
 > 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
 the corresponding .NET classes. Both classes let you choose the byte order
 (`big`- or `little`-endian) and support 8-, 16-, 32- and 64-bit integers, floats,
-doubles, and raw byte runs.
+doubles, raw byte runs, and encoded strings.
 
 ## Table of contents
 
@@ -24,14 +29,17 @@ doubles, and raw byte runs.
 - [Requirements and compatibility](#requirements-and-compatibility)
 - [Testing](#testing)
 - [Contributing](#contributing)
+- [License](#license)
 
 ## Features
 
 - Sequential `Read*` / `Write*` methods for every common fixed-width type.
 - Per-instance endianness (`big` by default, or `little`).
 - 64-bit integers via JavaScript `BigInt`.
-- Signed and unsigned integers, IEEE-754 `float` and `double`, and raw byte runs.
+- Signed and unsigned integers, IEEE-754 `float` and `double`, raw byte runs, and
+  strings in any `Buffer` encoding.
 - Zero runtime dependencies.
+- Bundled TypeScript type definitions.
 
 ## Installation
 
@@ -83,7 +91,7 @@ you read.
 | ------------ | ----------------------------- | ------- | ------------------------------------------------------------------ |
 | `input`      | `Buffer` \| `number[]` \| `string` | —  | The data to read. A `Buffer` is **copied** so the source is never mutated. |
 | `endianness` | `'big'` \| `'little'`         | `'big'` | Byte order used by all multi-byte reads.                           |
-| `encoding`   | `string`                      | `'ascii'` | Used only when `input` is a `string`, to turn it into bytes.     |
+| `encoding`   | `string`                      | `'ascii'` | Used to turn a `string` input into bytes, and by `ReadString`.   |
 
 Throws `Error` if `input` is not a `Buffer`, array, or string.
 
@@ -102,10 +110,11 @@ Throws `Error` if `input` is not a `Buffer`, array, or string.
 | `ReadFloat()`     | 4     | `number`  | IEEE-754 single precision.                     |
 | `ReadDouble()`    | 8     | `number`  | IEEE-754 double precision.                     |
 | `ReadBytes(count)`| `count` | `Buffer`| Copies `count` bytes into a new `Buffer`.      |
+| `ReadString(count)`| `count` | `string`| Decodes `count` bytes using the instance's `Encoding`. |
 
 If fewer than the required number of bytes remain, integer/float reads return `0`
-(or `0.0`), and `ReadBytes` returns an empty `Buffer` — **without** throwing or
-advancing the position. See [Behavior and best practices](#behavior-and-best-practices).
+(or `0.0`), and `ReadBytes`/`ReadString` return an empty `Buffer`/`string` — **without**
+throwing or advancing the position. See [Behavior and best practices](#behavior-and-best-practices).
 
 #### Reader properties
 
@@ -126,7 +135,7 @@ A writer accumulates bytes in an internal buffer that grows with every write.
 | Parameter    | Type                  | Default   | Description                              |
 | ------------ | --------------------- | --------- | ---------------------------------------- |
 | `endianness` | `'big'` \| `'little'` | `'big'`   | Byte order used by all multi-byte writes.|
-| `encoding`   | `string`              | `'ascii'` | Stored on the instance; reserved.        |
+| `encoding`   | `string`              | `'ascii'` | Used by `WriteString` to encode strings. |
 
 #### Write methods
 
@@ -143,6 +152,7 @@ A writer accumulates bytes in an internal buffer that grows with every write.
 | `WriteFloat(value)`   | 4     | `number`            | IEEE-754 single precision.                         |
 | `WriteDouble(value)`  | 8     | `number`            | IEEE-754 double precision.                         |
 | `WriteBytes(value)`   | varies| `Buffer` \| `number[]` \| `string` | Strings are written as one byte per character code. Throws on any other type. |
+| `WriteString(value)`  | varies| `string`            | Encodes the string using the instance's `Encoding`. Throws on any other type. |
 
 Writing a value outside the target type's range throws a `RangeError` (the standard
 Node.js `Buffer` write behavior) — e.g. `WriteUInt8(256)`.
@@ -184,6 +194,11 @@ Node.js `Buffer` write behavior) — e.g. `WriteUInt8(256)`.
 - **Constructing a reader from a string?** Pass the encoding explicitly
   (e.g. `new BinaryReader(text, 'big', 'utf8')`) so the bytes are interpreted the
   way you expect.
+- **The default `'ascii'` encoding is 7-bit only.** Node.js clears the high bit of
+  every byte when decoding `'ascii'`, so text containing characters above `0x7F`
+  does **not** round-trip through `WriteString`/`ReadString` with the default
+  encoding. Pass `'utf8'` (or `'latin1'`) to both constructors when handling
+  non-ASCII text.
 
 ## Examples
 
@@ -213,6 +228,21 @@ const reader = new BinaryReader(writer.ByteBuffer, 'little');
 console.log(reader.ReadUInt32().toString(16)); // "1020304"
 ```
 
+### Writing and reading strings
+
+```javascript
+const { BinaryReader, BinaryWriter } = require('binutils64');
+
+const text = 'héllo';
+const writer = new BinaryWriter('big', 'utf8');
+writer.WriteUInt8(Buffer.byteLength(text, 'utf8')); // length prefix: 6
+writer.WriteString(text);
+
+const reader = new BinaryReader(writer.ByteBuffer, 'big', 'utf8');
+const length = reader.ReadUInt8();                  // 6
+console.log(reader.ReadString(length));             // "héllo"
+```
+
 ### Parsing a structured record
 
 ```javascript
@@ -232,11 +262,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 +283,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,87 @@
+/// <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 and to decode `ReadString`. */
+        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;
+        /** Decodes `count` bytes as a string using the instance's `Encoding`. Returns an empty string (without advancing) if fewer than `count` bytes remain. */
+        ReadString(count: number): string;
+    }
+
+    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;
+        /** Encoding used by `WriteString`. */
+        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;
+        /** Encodes the string using the instance's `Encoding`. Throws on any other input type. */
+        WriteString(value: 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,14 +134,25 @@ 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);
 
+        this.Position += p_Count;
+        return s_Val;
+    },
+
+    ReadString: function(p_Count) {
+        if (p_Count <= 0 || p_Count > this.ByteBuffer.length) {
+            return '';
+        }
+
+        var s_Val = this.ByteBuffer.toString(this.Encoding, 0, p_Count);
+        this.ByteBuffer = this.ByteBuffer.slice(p_Count);
         this.Position += p_Count;
         return s_Val;
     }
@@ -151,7 +162,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 +176,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 +194,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 +205,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 +217,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 +235,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 +246,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 +258,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 +269,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,8 +296,18 @@ 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);
+    },
+
+    WriteString: function(p_Value) {
+        if (typeof p_Value != 'string') {
+            throw new Error("Invalid string provided.");
+        }
 
+        var s_TempBuffer = Buffer.from(p_Value, this.Encoding);
         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.3.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 *)"
-    ]
-  }
-}