Buffer Builder

0.2.0 · abandoned · verified Sun Apr 19

This package, `buffer-builder`, provides a utility for incrementally constructing a Node.js `Buffer` without prior knowledge of its final size. It offers methods to append strings, existing buffers, and various integer/float types (e.g., `appendUInt32LE`, `appendFloatBE), as well as a byte fill operation. The current stable version is 0.2.0, last published over a decade ago in January 2015. Due to its age, it directly relies on the now-deprecated `new Buffer()` constructor, which poses significant security and usability issues in modern Node.js environments. This package is effectively abandoned, with no active development or updates to address compatibility with contemporary Node.js Buffer APIs (like `Buffer.from`, `Buffer.alloc`). Developers seeking similar functionality should consider actively maintained alternatives or Node.js's built-in `Buffer.concat` with an array of smaller buffers.

Common errors

```
TypeError: Buffer is not a constructor
```
cause Attempting to instantiate `Buffer` using `new Buffer()` in Node.js v10.0.0 or later, which removed the `Buffer` constructor. This package internally uses `new Buffer()` which leads to this error.

fix This package is incompatible with Node.js v10+. Either downgrade your Node.js version (not recommended) or replace `buffer-builder` with an actively maintained alternative that uses `Buffer.from()` or `Buffer.alloc()`.
```
(node:XXXX) [DEP0005] DeprecationWarning: Buffer() is deprecated due to security and usability issues. Please use the Buffer.alloc(), Buffer.allocUnsafe(), or Buffer.from() methods instead.
```
cause Running `buffer-builder` with Node.js v6.0.0 through v9.x.x. The package uses `new Buffer()` which is formally deprecated during this range.

fix This warning indicates the package uses an outdated and potentially insecure API. While it might still function, it's a strong signal to migrate to a modern, actively maintained buffer building library to avoid future breaking changes and security risks. You can suppress the warning with `--no-deprecation` but this is not recommended.

Warnings

breaking The `buffer-builder` package internally uses `new Buffer()`, which was deprecated in Node.js v6.0.0 and removed in v10.0.0. Using this package with Node.js v10 or newer will cause runtime errors because `Buffer` is no longer a constructor.
Fix: This package is effectively abandoned. For projects requiring Node.js v10+, consider alternative buffer building libraries or use native `Buffer.alloc()`, `Buffer.from()`, and `Buffer.concat()` with an array of buffers. If you must use this package with older Node.js versions, ensure your project's Node.js runtime is <10.0.0.
gotcha The package has not been updated since January 2015, making it highly susceptible to compatibility issues with newer Node.js versions, security vulnerabilities discovered since its last release, and lack of modern JavaScript features (e.g., ESM).
Fix: It is strongly recommended to migrate away from this package to actively maintained alternatives. If unable to migrate, thoroughly audit the package for security vulnerabilities and test rigorously with your specific Node.js version.
deprecated The documentation's usage example uses `new Buffer([...])`. This method creates an uninitialized buffer which can expose sensitive memory contents and is a security risk.
Fix: Always use `Buffer.from()` when creating a buffer from data (e.g., `Buffer.from([111, 114, 108, 100])`) or `Buffer.alloc()` for a zero-filled buffer of a specific size (e.g., `Buffer.alloc(10)`). The quickstart code reflects this change.

Install

npm install buffer-builder npm
yarn add buffer-builder yarn
pnpm add buffer-builder pnpm

Imports

BufferBuilder
wrong:
```
const BufferBuilder = require('buffer-builder');
```
correct:
```
import BufferBuilder from 'buffer-builder';
```
While CommonJS `require` is shown in the original documentation, modern Node.js projects typically use ESM `import`. This package was published before widespread ESM adoption, so direct ESM compatibility may be limited without a transpilation layer. However, Node.js allows `import` of CJS modules.
Buffer
wrong:
```
const Buffer = require('buffer');
```
correct:
```
import { Buffer } from 'node:buffer';
```
This package relies heavily on the global `Buffer` object or `require('buffer')`. For explicit import and modern Node.js practices, use `import { Buffer } from 'node:buffer';`. Be aware that the package's internal use of `new Buffer()` is deprecated.

Quickstart

Demonstrates initializing BufferBuilder, appending various data types, and retrieving the final Buffer, updated for modern Node.js Buffer API usage.

import BufferBuilder from 'buffer-builder';
import { Buffer } from 'node:buffer';

const helloWorld = new BufferBuilder();

// Append a string, utf8 encoded by default.
helloWorld.appendString('hello');

// Append any type that Buffer has read and write functions for.
helloWorld.appendUInt16LE(0x7720);

// Append a buffer - using Buffer.from() for modern Node.js compatibility
helloWorld.appendBuffer(Buffer.from([111, 114, 108, 100]));

// Appended a repetition of a byte
helloWorld.appendFill(33, 3);

// Convert to an ordinary buffer
const buffer = helloWorld.get();

console.log(buffer.toString()); // Expected: hello world!!!

view raw JSON →